Sophie Dexter / Mbed 2 deprecated Just4Trionic

Just4Trionic - CAN and BDM FLASH programmer for Saab cars

Dependencies:   mbed

canutils.cpp@4:682d96ff6d79, 2013-09-11 (annotated)

Committer:
Just4pLeisure
Date:
Wed Sep 11 11:55:51 2013 +0000
Revision:
4:682d96ff6d79
Parent:
3:92dae9083c83
Child:
5:1775b4b13232
This update adds T8 CAN DUMP and FLASH capability (recovery still to do)

Who changed what in which revision?

UserRevisionLine numberNew contents of line
Just4pLeisure 1:d5452e398b76 1 /*******************************************************************************
Just4pLeisure 1:d5452e398b76 2
Just4pLeisure 1:d5452e398b76 3 canutils.cpp
Just4pLeisure 4:682d96ff6d79 4 (c) 2010, 2012 by Sophie Dexter
Just4pLeisure 1:d5452e398b76 5
Just4pLeisure 1:d5452e398b76 6 General purpose CAN bus functions for Just4Trionic by Just4pLeisure
Just4pLeisure 1:d5452e398b76 7 Functions that work with the CAN bus directly. Anything to do with the CAN bus
Just4pLeisure 1:d5452e398b76 8 must (should anyway) be done by one of these functions.
Just4pLeisure 1:d5452e398b76 9
Just4pLeisure 1:d5452e398b76 10 ********************************************************************************
Just4pLeisure 1:d5452e398b76 11
Just4pLeisure 1:d5452e398b76 12 WARNING: Use at your own risk, sadly this software comes with no guarantees.
Just4pLeisure 1:d5452e398b76 13 This software is provided 'free' and in good faith, but the author does not
Just4pLeisure 1:d5452e398b76 14 accept liability for any damage arising from its use.
Just4pLeisure 1:d5452e398b76 15
Just4pLeisure 1:d5452e398b76 16 *******************************************************************************/
Just4pLeisure 1:d5452e398b76 17
Just4pLeisure 1:d5452e398b76 18 #include "canutils.h"
Just4pLeisure 1:d5452e398b76 19
Just4pLeisure 1:d5452e398b76 20 //CAN can2(p30, p29);
Just4pLeisure 1:d5452e398b76 21 // Use a timer to see if things take too long
Just4pLeisure 1:d5452e398b76 22 Timer CANTimer;
Just4pLeisure 1:d5452e398b76 23
Just4pLeisure 1:d5452e398b76 24
Just4pLeisure 4:682d96ff6d79 25 //LPC_CANx->MOD |= 1; // Disble CAN controller 2
Just4pLeisure 4:682d96ff6d79 26 //LPC_CANx->MOD |= (1 << 1); // Put into listen only mode
Just4pLeisure 4:682d96ff6d79 27 //LPC_CANx->MOD &= ~(1); // Re-enable CAN controller
Just4pLeisure 4:682d96ff6d79 28
Just4pLeisure 4:682d96ff6d79 29 void can_disable(uint8_t chan) {
Just4pLeisure 4:682d96ff6d79 30 // Put a CAN controller into disabled condition
Just4pLeisure 4:682d96ff6d79 31 chan == 1 ? LPC_CAN1->MOD |= 1 : LPC_CAN2->MOD |= 1;
Just4pLeisure 4:682d96ff6d79 32 }
Just4pLeisure 4:682d96ff6d79 33
Just4pLeisure 4:682d96ff6d79 34 void can_enable(uint8_t chan) {
Just4pLeisure 4:682d96ff6d79 35 // Put a CAN controller in operating mode
Just4pLeisure 4:682d96ff6d79 36 chan == 1 ? LPC_CAN1->MOD &= ~(1) : LPC_CAN2->MOD &= ~(1);
Just4pLeisure 4:682d96ff6d79 37 }
Just4pLeisure 4:682d96ff6d79 38
Just4pLeisure 4:682d96ff6d79 39 void can_configure(uint8_t chan, uint32_t baud, bool listen) {
Just4pLeisure 4:682d96ff6d79 40
Just4pLeisure 4:682d96ff6d79 41 LPC_CAN_TypeDef *pCANx = (chan == 1) ? LPC_CAN1 : LPC_CAN2;
Just4pLeisure 4:682d96ff6d79 42
Just4pLeisure 4:682d96ff6d79 43 uint32_t result;
Just4pLeisure 4:682d96ff6d79 44 uint8_t TQU, TSEG1=0, TSEG2=0;
Just4pLeisure 4:682d96ff6d79 45 uint16_t BRP=0;
Just4pLeisure 4:682d96ff6d79 46
Just4pLeisure 4:682d96ff6d79 47 switch (chan) {
Just4pLeisure 4:682d96ff6d79 48 case 1:
Just4pLeisure 4:682d96ff6d79 49 LPC_SC->PCONP |= (1 << 13); // Enable CAN controller 1
Just4pLeisure 4:682d96ff6d79 50 LPC_PINCON->PINSEL0 |= (1 << 0); // Pin 9 (port0 bit0) used as Receive
Just4pLeisure 4:682d96ff6d79 51 LPC_PINCON->PINSEL0 |= (1 << 2); // Pin 10 (port0 bit1) used as Transmit
Just4pLeisure 4:682d96ff6d79 52 break;
Just4pLeisure 4:682d96ff6d79 53 case 2:
Just4pLeisure 4:682d96ff6d79 54 default:
Just4pLeisure 4:682d96ff6d79 55 LPC_SC->PCONP |= (1 << 14); // Enable CAN controller 2
Just4pLeisure 4:682d96ff6d79 56 LPC_PINCON->PINSEL0 |= (1 << 9); // Pin 30 (port0 bit4) used as Receive
Just4pLeisure 4:682d96ff6d79 57 LPC_PINCON->PINSEL0 |= (1 << 11); // Pin 29 (port0 bit5) used as Transmit
Just4pLeisure 4:682d96ff6d79 58 break;
Just4pLeisure 4:682d96ff6d79 59 }
Just4pLeisure 4:682d96ff6d79 60 pCANx->MOD = 0x01; // Put into reset mode
Just4pLeisure 4:682d96ff6d79 61
Just4pLeisure 4:682d96ff6d79 62 pCANx->IER = 0; // Disable all interrupts
Just4pLeisure 4:682d96ff6d79 63 pCANx->GSR = 0; // Clear status register
Just4pLeisure 4:682d96ff6d79 64 pCANx->CMR = (1<<1)|(1<<2)|(1<<3); // Clear Receive path, abort anything waiting to send and clear errors
Just4pLeisure 4:682d96ff6d79 65 // CANx->CMR = CAN_CMR_AT | CAN_CMR_RRB | CAN_CMR_CDO;
Just4pLeisure 4:682d96ff6d79 66 result = pCANx->ICR; // Read interrupt register to clear it
Just4pLeisure 4:682d96ff6d79 67
Just4pLeisure 4:682d96ff6d79 68 // Calculate a suitable BTR register setting
Just4pLeisure 4:682d96ff6d79 69 // The Bit Rate Pre-scaler (BRP) can be in the range of 1-1024
Just4pLeisure 4:682d96ff6d79 70 // Bit Time can be be between 25 and 8 Time Quanta (TQU) according to CANopen
Just4pLeisure 4:682d96ff6d79 71 // Bit Time = SyncSeg(1) + TSEG1(1-16) + TSEG2(1-8)
Just4pLeisure 4:682d96ff6d79 72 // SyncSeg is always 1TQU, TSEG2 must be at least 2TQU to be longer than the processing time
Just4pLeisure 4:682d96ff6d79 73 // Opinions vary on when to take a sample but a point roughly 2/3 of Bit Time seems OK, TSEG1 is roughly 2*TSEG2
Just4pLeisure 4:682d96ff6d79 74 // Synchronisation Jump width can be 1-4 TQU, a value of 1 seems to be normal
Just4pLeisure 4:682d96ff6d79 75 // All register values are -1, e.g. TSEG1 can range from 1-16 TQU, so register values are 0-15 to fit into 4 bits
Just4pLeisure 4:682d96ff6d79 76 result = CANsuppliedCLK / baud;
Just4pLeisure 4:682d96ff6d79 77 for (TQU=25; TQU>7; TQU--) {
Just4pLeisure 4:682d96ff6d79 78 if ((result%TQU)==0) {
Just4pLeisure 4:682d96ff6d79 79 BRP = (result/TQU) - 1;
Just4pLeisure 4:682d96ff6d79 80 TSEG2 = (TQU/3) - 1; // Subtract 1
Just4pLeisure 4:682d96ff6d79 81 TSEG1 = TQU - (TQU/3) - 2; // Subtract 2 to allow for SyncSeg
Just4pLeisure 4:682d96ff6d79 82 break;
Just4pLeisure 4:682d96ff6d79 83 }
Just4pLeisure 4:682d96ff6d79 84 }
Just4pLeisure 4:682d96ff6d79 85 pCANx->BTR = (TSEG2<<20)|(TSEG1<<16)|(0<<14)|BRP; // Set bit timing, SAM = 0, TSEG2, TSEG1, SJW = 1 (0+1), BRP
Just4pLeisure 4:682d96ff6d79 86
Just4pLeisure 4:682d96ff6d79 87 can_reset_filters(); // Initialise the Acceptance Filters
Just4pLeisure 4:682d96ff6d79 88 can_use_filters(FALSE); // Accept all messages (Acceptance Filters disabled)
Just4pLeisure 4:682d96ff6d79 89 // Go :-)
Just4pLeisure 4:682d96ff6d79 90 can_rs_pin = listen; // enable/disable CAN driver chip
Just4pLeisure 4:682d96ff6d79 91 pCANx->MOD = (listen <<1); // Enable CAN controller in active/listen mode
Just4pLeisure 4:682d96ff6d79 92 }
Just4pLeisure 4:682d96ff6d79 93
Just4pLeisure 4:682d96ff6d79 94
Just4pLeisure 4:682d96ff6d79 95 void can_reset_filters() {
Just4pLeisure 4:682d96ff6d79 96 // Initialise the Acceptance Filters
Just4pLeisure 4:682d96ff6d79 97 LPC_CANAF->AFMR = 0x01; // Put Acceptance Filter into reset/configuration mode
Just4pLeisure 4:682d96ff6d79 98 for (uint16_t i = 0; i < 512; i++)
Just4pLeisure 4:682d96ff6d79 99 LPC_CANAF_RAM->mask[i] = 0x00; // Clear the Acceptance Filter memory
Just4pLeisure 4:682d96ff6d79 100 LPC_CANAF->SFF_sa = 0x00; // Clear the Acceptance Filter registers
Just4pLeisure 4:682d96ff6d79 101 LPC_CANAF->SFF_GRP_sa = 0x00;
Just4pLeisure 4:682d96ff6d79 102 LPC_CANAF->EFF_sa = 0x00;
Just4pLeisure 4:682d96ff6d79 103 LPC_CANAF->EFF_GRP_sa = 0x00;
Just4pLeisure 4:682d96ff6d79 104 LPC_CANAF->ENDofTable = 0x00;
Just4pLeisure 4:682d96ff6d79 105 LPC_CANAF->AFMR = 0x00; // Enable Acceptance Filter all messages should be rejected
Just4pLeisure 4:682d96ff6d79 106 }
Just4pLeisure 4:682d96ff6d79 107
Just4pLeisure 4:682d96ff6d79 108 void can_use_filters(bool active) {
Just4pLeisure 4:682d96ff6d79 109 active ? LPC_CANAF->AFMR = 0 : LPC_CANAF->AFMR = 2;
Just4pLeisure 4:682d96ff6d79 110 }
Just4pLeisure 4:682d96ff6d79 111
Just4pLeisure 4:682d96ff6d79 112 /*--------------------------------------------
Just4pLeisure 4:682d96ff6d79 113 setup acceptance filter for CAN controller 2
Just4pLeisure 4:682d96ff6d79 114 original http://www.dragonwake.com/download/LPC1768/Example/CAN/CAN.c
Just4pLeisure 4:682d96ff6d79 115 simplified for CAN2 interface and std id (11 bit) only
Just4pLeisure 4:682d96ff6d79 116 *--------------------------------------------*/
Just4pLeisure 4:682d96ff6d79 117 void can_add_filter(uint8_t chan, uint32_t id) {
Just4pLeisure 4:682d96ff6d79 118
Just4pLeisure 4:682d96ff6d79 119 static int CAN_std_cnt = 0;
Just4pLeisure 4:682d96ff6d79 120 uint32_t buf0, buf1;
Just4pLeisure 4:682d96ff6d79 121 int cnt1, cnt2, bound1;
Just4pLeisure 4:682d96ff6d79 122
Just4pLeisure 4:682d96ff6d79 123 /* Acceptance Filter Memory full */
Just4pLeisure 4:682d96ff6d79 124 if (((CAN_std_cnt + 1) >> 1) >= 512)
Just4pLeisure 4:682d96ff6d79 125 return; // error: objects full
Just4pLeisure 4:682d96ff6d79 126
Just4pLeisure 4:682d96ff6d79 127 /* Setup Acceptance Filter Configuration
Just4pLeisure 4:682d96ff6d79 128 Acceptance Filter Mode Register = Off */
Just4pLeisure 4:682d96ff6d79 129 LPC_CANAF->AFMR = 0x00000001;
Just4pLeisure 4:682d96ff6d79 130
Just4pLeisure 4:682d96ff6d79 131 id &= 0x000007FF; // Mask out 16-bits of ID
Just4pLeisure 4:682d96ff6d79 132 id |= (chan-1) << 13; // Add CAN controller number (1 or 2)
Just4pLeisure 4:682d96ff6d79 133
Just4pLeisure 4:682d96ff6d79 134 if (CAN_std_cnt == 0) { /* For entering first ID */
Just4pLeisure 4:682d96ff6d79 135 LPC_CANAF_RAM->mask[0] = 0x0000FFFF | (id << 16);
Just4pLeisure 4:682d96ff6d79 136 } else if (CAN_std_cnt == 1) { /* For entering second ID */
Just4pLeisure 4:682d96ff6d79 137 if ((LPC_CANAF_RAM->mask[0] >> 16) > id)
Just4pLeisure 4:682d96ff6d79 138 LPC_CANAF_RAM->mask[0] = (LPC_CANAF_RAM->mask[0] >> 16) | (id << 16);
Just4pLeisure 4:682d96ff6d79 139 else
Just4pLeisure 4:682d96ff6d79 140 LPC_CANAF_RAM->mask[0] = (LPC_CANAF_RAM->mask[0] & 0xFFFF0000) | id;
Just4pLeisure 4:682d96ff6d79 141 } else {
Just4pLeisure 4:682d96ff6d79 142 /* Find where to insert new ID */
Just4pLeisure 4:682d96ff6d79 143 cnt1 = 0;
Just4pLeisure 4:682d96ff6d79 144 cnt2 = CAN_std_cnt;
Just4pLeisure 4:682d96ff6d79 145 bound1 = (CAN_std_cnt - 1) >> 1;
Just4pLeisure 4:682d96ff6d79 146 while (cnt1 <= bound1) { /* Loop through standard existing IDs */
Just4pLeisure 4:682d96ff6d79 147 if ((LPC_CANAF_RAM->mask[cnt1] >> 16) > id) {
Just4pLeisure 4:682d96ff6d79 148 cnt2 = cnt1 * 2;
Just4pLeisure 4:682d96ff6d79 149 break;
Just4pLeisure 4:682d96ff6d79 150 }
Just4pLeisure 4:682d96ff6d79 151 if ((LPC_CANAF_RAM->mask[cnt1] & 0x0000FFFF) > id) {
Just4pLeisure 4:682d96ff6d79 152 cnt2 = cnt1 * 2 + 1;
Just4pLeisure 4:682d96ff6d79 153 break;
Just4pLeisure 4:682d96ff6d79 154 }
Just4pLeisure 4:682d96ff6d79 155 cnt1++; /* cnt1 = U32 where to insert new ID */
Just4pLeisure 4:682d96ff6d79 156 } /* cnt2 = U16 where to insert new ID */
Just4pLeisure 4:682d96ff6d79 157
Just4pLeisure 4:682d96ff6d79 158 if (cnt1 > bound1) { /* Adding ID as last entry */
Just4pLeisure 4:682d96ff6d79 159 if ((CAN_std_cnt & 0x0001) == 0) /* Even number of IDs exists */
Just4pLeisure 4:682d96ff6d79 160 LPC_CANAF_RAM->mask[cnt1] = 0x0000FFFF | (id << 16);
Just4pLeisure 4:682d96ff6d79 161 else /* Odd number of IDs exists */
Just4pLeisure 4:682d96ff6d79 162 LPC_CANAF_RAM->mask[cnt1] = (LPC_CANAF_RAM->mask[cnt1] & 0xFFFF0000) | id;
Just4pLeisure 4:682d96ff6d79 163 } else {
Just4pLeisure 4:682d96ff6d79 164 buf0 = LPC_CANAF_RAM->mask[cnt1]; /* Remember current entry */
Just4pLeisure 4:682d96ff6d79 165 if ((cnt2 & 0x0001) == 0) /* Insert new mask to even address */
Just4pLeisure 4:682d96ff6d79 166 buf1 = (id << 16) | (buf0 >> 16);
Just4pLeisure 4:682d96ff6d79 167 else /* Insert new mask to odd address */
Just4pLeisure 4:682d96ff6d79 168 buf1 = (buf0 & 0xFFFF0000) | id;
Just4pLeisure 4:682d96ff6d79 169
Just4pLeisure 4:682d96ff6d79 170 LPC_CANAF_RAM->mask[cnt1] = buf1; /* Insert mask */
Just4pLeisure 4:682d96ff6d79 171
Just4pLeisure 4:682d96ff6d79 172 bound1 = CAN_std_cnt >> 1;
Just4pLeisure 4:682d96ff6d79 173 /* Move all remaining standard mask entries one place up */
Just4pLeisure 4:682d96ff6d79 174 while (cnt1 < bound1) {
Just4pLeisure 4:682d96ff6d79 175 cnt1++;
Just4pLeisure 4:682d96ff6d79 176 buf1 = LPC_CANAF_RAM->mask[cnt1];
Just4pLeisure 4:682d96ff6d79 177 LPC_CANAF_RAM->mask[cnt1] = (buf1 >> 16) | (buf0 << 16);
Just4pLeisure 4:682d96ff6d79 178 buf0 = buf1;
Just4pLeisure 4:682d96ff6d79 179 }
Just4pLeisure 4:682d96ff6d79 180
Just4pLeisure 4:682d96ff6d79 181 if ((CAN_std_cnt & 0x0001) == 0) /* Even number of IDs exists */
Just4pLeisure 4:682d96ff6d79 182 LPC_CANAF_RAM->mask[cnt1] = (LPC_CANAF_RAM->mask[cnt1] & 0xFFFF0000) | (0x0000FFFF);
Just4pLeisure 4:682d96ff6d79 183 }
Just4pLeisure 4:682d96ff6d79 184 }
Just4pLeisure 4:682d96ff6d79 185 CAN_std_cnt++;
Just4pLeisure 4:682d96ff6d79 186
Just4pLeisure 4:682d96ff6d79 187 /* Calculate std ID start address (buf0) and ext ID start address <- none (buf1) */
Just4pLeisure 4:682d96ff6d79 188 buf0 = ((CAN_std_cnt + 1) >> 1) << 2;
Just4pLeisure 4:682d96ff6d79 189 /* Setup acceptance filter pointers */
Just4pLeisure 4:682d96ff6d79 190 LPC_CANAF->SFF_sa = 0;
Just4pLeisure 4:682d96ff6d79 191 LPC_CANAF->SFF_GRP_sa = buf0;
Just4pLeisure 4:682d96ff6d79 192 LPC_CANAF->EFF_sa = buf0;
Just4pLeisure 4:682d96ff6d79 193 LPC_CANAF->EFF_GRP_sa = buf0;
Just4pLeisure 4:682d96ff6d79 194 LPC_CANAF->ENDofTable = buf0;
Just4pLeisure 4:682d96ff6d79 195
Just4pLeisure 4:682d96ff6d79 196 LPC_CANAF->AFMR = 0x00000000; /* Use acceptance filter */
Just4pLeisure 4:682d96ff6d79 197 } // CAN2_wrFilter
Just4pLeisure 4:682d96ff6d79 198
Just4pLeisure 4:682d96ff6d79 199
Just4pLeisure 1:d5452e398b76 200 void can_open() {
Just4pLeisure 1:d5452e398b76 201 // activate external can transceiver
Just4pLeisure 1:d5452e398b76 202 can.reset();
Just4pLeisure 1:d5452e398b76 203 can_rs_pin = 0;
Just4pLeisure 1:d5452e398b76 204 }
Just4pLeisure 1:d5452e398b76 205
Just4pLeisure 1:d5452e398b76 206 void can_close() {
Just4pLeisure 1:d5452e398b76 207 // disable external can transceiver
Just4pLeisure 1:d5452e398b76 208 can_rs_pin = 1;
Just4pLeisure 1:d5452e398b76 209 can.reset();
Just4pLeisure 1:d5452e398b76 210 }
Just4pLeisure 1:d5452e398b76 211
Just4pLeisure 4:682d96ff6d79 212 void can_monitor() {
Just4pLeisure 4:682d96ff6d79 213 // Put CAN into silent monitoring mode
Just4pLeisure 4:682d96ff6d79 214 can.monitor(1);
Just4pLeisure 4:682d96ff6d79 215 }
Just4pLeisure 4:682d96ff6d79 216
Just4pLeisure 4:682d96ff6d79 217 void can_active() {
Just4pLeisure 4:682d96ff6d79 218 // Take CAN out of silent monitoring mode
Just4pLeisure 4:682d96ff6d79 219 can.monitor(0);
Just4pLeisure 4:682d96ff6d79 220 }
Just4pLeisure 4:682d96ff6d79 221
Just4pLeisure 1:d5452e398b76 222 uint8_t can_set_speed(uint32_t speed) {
Just4pLeisure 1:d5452e398b76 223 // 600kbit/s first - basically sets up CAN interface, but to wrong speed - not sure what else it does
Just4pLeisure 1:d5452e398b76 224 // can.frequency(600000);
Just4pLeisure 1:d5452e398b76 225 // 615kbit/s direct write of 615 kbit/s speed setting
Just4pLeisure 1:d5452e398b76 226 // LPC_CAN2->BTR = 0x370002;
Just4pLeisure 1:d5452e398b76 227 return (can.frequency(speed)) ? TERM_OK : TERM_ERR;
Just4pLeisure 1:d5452e398b76 228 }
Just4pLeisure 1:d5452e398b76 229
Just4pLeisure 3:92dae9083c83 230 //
Just4pLeisure 3:92dae9083c83 231 // show_can_message
Just4pLeisure 3:92dae9083c83 232 //
Just4pLeisure 3:92dae9083c83 233 // Displays a CAN message in the RX buffer if there is one.
Just4pLeisure 3:92dae9083c83 234 //
Just4pLeisure 3:92dae9083c83 235 // inputs: none
Just4pLeisure 3:92dae9083c83 236 // return: bool TRUE if there was a message, FALSE if no message.
Just4pLeisure 3:92dae9083c83 237 //
Just4pLeisure 3:92dae9083c83 238 extern void show_can_message() {
Just4pLeisure 1:d5452e398b76 239 CANMessage can_MsgRx;
Just4pLeisure 1:d5452e398b76 240 if (can.read(can_MsgRx)) {
Just4pLeisure 3:92dae9083c83 241 CANRXLEDON;
Just4pLeisure 1:d5452e398b76 242 printf("w%03x%d", can_MsgRx.id, can_MsgRx.len);
Just4pLeisure 3:92dae9083c83 243 for (char i=0; i<can_MsgRx.len; i++)
Just4pLeisure 1:d5452e398b76 244 printf("%02x", can_MsgRx.data[i]);
Just4pLeisure 4:682d96ff6d79 245 //printf(" %c ", can_MsgRx.data[2]);
Just4pLeisure 1:d5452e398b76 246 printf("\r\n");
Just4pLeisure 1:d5452e398b76 247 }
Just4pLeisure 3:92dae9083c83 248 return;
Just4pLeisure 3:92dae9083c83 249 }
Just4pLeisure 3:92dae9083c83 250
Just4pLeisure 3:92dae9083c83 251 //
Just4pLeisure 4:682d96ff6d79 252 // show_T5can_message
Just4pLeisure 4:682d96ff6d79 253 //
Just4pLeisure 4:682d96ff6d79 254 // Displays a Trionic 5 CAN message in the RX buffer if there is one.
Just4pLeisure 4:682d96ff6d79 255 //
Just4pLeisure 4:682d96ff6d79 256 // inputs: none
Just4pLeisure 4:682d96ff6d79 257 // return: bool TRUE if there was a message, FALSE if no message.
Just4pLeisure 4:682d96ff6d79 258 //
Just4pLeisure 4:682d96ff6d79 259 extern void show_T5can_message() {
Just4pLeisure 4:682d96ff6d79 260 CANMessage can_MsgRx;
Just4pLeisure 4:682d96ff6d79 261 if (can.read(can_MsgRx)) {
Just4pLeisure 4:682d96ff6d79 262 CANRXLEDON;
Just4pLeisure 4:682d96ff6d79 263 switch (can_MsgRx.id) {
Just4pLeisure 4:682d96ff6d79 264 case 0x005:
Just4pLeisure 4:682d96ff6d79 265 case 0x006:
Just4pLeisure 4:682d96ff6d79 266 case 0x00C:
Just4pLeisure 4:682d96ff6d79 267 case 0x008:
Just4pLeisure 4:682d96ff6d79 268 printf("w%03x%d", can_MsgRx.id, can_MsgRx.len);
Just4pLeisure 4:682d96ff6d79 269 for (char i=0; i<can_MsgRx.len; i++)
Just4pLeisure 4:682d96ff6d79 270 printf("%02x", can_MsgRx.data[i]);
Just4pLeisure 4:682d96ff6d79 271 printf("\r\n");
Just4pLeisure 4:682d96ff6d79 272 break;
Just4pLeisure 4:682d96ff6d79 273 }
Just4pLeisure 4:682d96ff6d79 274 }
Just4pLeisure 4:682d96ff6d79 275 return;
Just4pLeisure 4:682d96ff6d79 276 }
Just4pLeisure 4:682d96ff6d79 277 //
Just4pLeisure 4:682d96ff6d79 278 // show_T7can_message
Just4pLeisure 4:682d96ff6d79 279 //
Just4pLeisure 4:682d96ff6d79 280 // Displays a Trionic 7 CAN message in the RX buffer if there is one.
Just4pLeisure 4:682d96ff6d79 281 //
Just4pLeisure 4:682d96ff6d79 282 // inputs: none
Just4pLeisure 4:682d96ff6d79 283 // return: bool TRUE if there was a message, FALSE if no message.
Just4pLeisure 4:682d96ff6d79 284 //
Just4pLeisure 4:682d96ff6d79 285 extern void show_T7can_message() {
Just4pLeisure 4:682d96ff6d79 286 CANMessage can_MsgRx;
Just4pLeisure 4:682d96ff6d79 287 if (can.read(can_MsgRx)) {
Just4pLeisure 4:682d96ff6d79 288 CANRXLEDON;
Just4pLeisure 4:682d96ff6d79 289 switch (can_MsgRx.id) {
Just4pLeisure 4:682d96ff6d79 290 case 0x1A0: //1A0h - Engine information
Just4pLeisure 4:682d96ff6d79 291 case 0x280: //280h - Pedals, reverse gear
Just4pLeisure 4:682d96ff6d79 292 case 0x290: //290h - Steering wheel and SID buttons
Just4pLeisure 4:682d96ff6d79 293 case 0x2F0: //2F0h - Vehicle speed
Just4pLeisure 4:682d96ff6d79 294 case 0x320: //320h - Doors, central locking and seat belts
Just4pLeisure 4:682d96ff6d79 295 case 0x370: //370h - Mileage
Just4pLeisure 4:682d96ff6d79 296 case 0x3A0: //3A0h - Vehicle speed
Just4pLeisure 4:682d96ff6d79 297 case 0x3B0: //3B0h - Head lights
Just4pLeisure 4:682d96ff6d79 298 case 0x3E0: //3E0h - Automatic Gearbox
Just4pLeisure 4:682d96ff6d79 299 case 0x410: //410h - Light dimmer and light sensor
Just4pLeisure 4:682d96ff6d79 300 case 0x430: //430h - SID beep request (interesting for Knock indicator?)
Just4pLeisure 4:682d96ff6d79 301 case 0x460: //460h - Engine rpm and speed
Just4pLeisure 4:682d96ff6d79 302 case 0x4A0: //4A0h - Steering wheel, Vehicle Identification Number
Just4pLeisure 4:682d96ff6d79 303 case 0x520: //520h - ACC, inside temperature
Just4pLeisure 4:682d96ff6d79 304 case 0x530: //530h - ACC
Just4pLeisure 4:682d96ff6d79 305 case 0x5C0: //5C0h - Coolant temperature, air pressure
Just4pLeisure 4:682d96ff6d79 306 case 0x630: //630h - Fuel usage
Just4pLeisure 4:682d96ff6d79 307 case 0x640: //640h - Mileage
Just4pLeisure 4:682d96ff6d79 308 case 0x7A0: //7A0h - Outside temperature
Just4pLeisure 4:682d96ff6d79 309 printf("w%03x%d", can_MsgRx.id, can_MsgRx.len);
Just4pLeisure 4:682d96ff6d79 310 for (char i=0; i<can_MsgRx.len; i++)
Just4pLeisure 4:682d96ff6d79 311 printf("%02x", can_MsgRx.data[i]);
Just4pLeisure 4:682d96ff6d79 312 //printf(" %c ", can_MsgRx.data[2]);
Just4pLeisure 4:682d96ff6d79 313 printf("\r\n");
Just4pLeisure 4:682d96ff6d79 314 break;
Just4pLeisure 4:682d96ff6d79 315 }
Just4pLeisure 4:682d96ff6d79 316 }
Just4pLeisure 4:682d96ff6d79 317 return;
Just4pLeisure 4:682d96ff6d79 318 }
Just4pLeisure 4:682d96ff6d79 319 //
Just4pLeisure 4:682d96ff6d79 320 // show_T8can_message
Just4pLeisure 4:682d96ff6d79 321 //
Just4pLeisure 4:682d96ff6d79 322 // Displays a Trionic 8 CAN message in the RX buffer if there is one.
Just4pLeisure 4:682d96ff6d79 323 //
Just4pLeisure 4:682d96ff6d79 324 // inputs: none
Just4pLeisure 4:682d96ff6d79 325 // return: bool TRUE if there was a message, FALSE if no message.
Just4pLeisure 4:682d96ff6d79 326 //
Just4pLeisure 4:682d96ff6d79 327 extern void show_T8can_message() {
Just4pLeisure 4:682d96ff6d79 328 CANMessage can_MsgRx;
Just4pLeisure 4:682d96ff6d79 329 if (can.read(can_MsgRx)) {
Just4pLeisure 4:682d96ff6d79 330 CANRXLEDON;
Just4pLeisure 4:682d96ff6d79 331 switch (can_MsgRx.id) {
Just4pLeisure 4:682d96ff6d79 332 case 0x645: // CIM
Just4pLeisure 4:682d96ff6d79 333 case 0x7E0:
Just4pLeisure 4:682d96ff6d79 334 case 0x7E8:
Just4pLeisure 4:682d96ff6d79 335 case 0x311:
Just4pLeisure 4:682d96ff6d79 336 case 0x5E8:
Just4pLeisure 4:682d96ff6d79 337 //case 0x101:
Just4pLeisure 4:682d96ff6d79 338 printf("w%03x%d", can_MsgRx.id, can_MsgRx.len);
Just4pLeisure 4:682d96ff6d79 339 for (char i=0; i<can_MsgRx.len; i++)
Just4pLeisure 4:682d96ff6d79 340 printf("%02x", can_MsgRx.data[i]);
Just4pLeisure 4:682d96ff6d79 341 printf("\r\n");
Just4pLeisure 4:682d96ff6d79 342 break;
Just4pLeisure 4:682d96ff6d79 343 }
Just4pLeisure 4:682d96ff6d79 344 }
Just4pLeisure 4:682d96ff6d79 345 return;
Just4pLeisure 4:682d96ff6d79 346 }
Just4pLeisure 4:682d96ff6d79 347
Just4pLeisure 4:682d96ff6d79 348 //
Just4pLeisure 3:92dae9083c83 349 // silent_can_message
Just4pLeisure 3:92dae9083c83 350 //
Just4pLeisure 3:92dae9083c83 351 // Turns on the CAN receive LED if there is a CAN message
Just4pLeisure 3:92dae9083c83 352 // but doesn't displays anything.
Just4pLeisure 3:92dae9083c83 353 //
Just4pLeisure 3:92dae9083c83 354 // inputs: none
Just4pLeisure 3:92dae9083c83 355 // return: bool TRUE if there was a message, FALSE if no message.
Just4pLeisure 3:92dae9083c83 356 //
Just4pLeisure 3:92dae9083c83 357 extern void silent_can_message() {
Just4pLeisure 3:92dae9083c83 358 CANMessage can_MsgRx;
Just4pLeisure 3:92dae9083c83 359 if (can.read(can_MsgRx)) {
Just4pLeisure 3:92dae9083c83 360 CANRXLEDON;
Just4pLeisure 3:92dae9083c83 361 }
Just4pLeisure 3:92dae9083c83 362 return;
Just4pLeisure 1:d5452e398b76 363 }
Just4pLeisure 1:d5452e398b76 364
Just4pLeisure 1:d5452e398b76 365 //
Just4pLeisure 1:d5452e398b76 366 // Sends a CAN Message, returns FALSE if the message wasn't sent in time
Just4pLeisure 1:d5452e398b76 367 //
Just4pLeisure 1:d5452e398b76 368 // inputs: integer CAN message 'id', pointer to 'frame', integer message length and integer timeout
Just4pLeisure 1:d5452e398b76 369 // return: TRUE if the CAN message was sent before the 'timeout' expires
Just4pLeisure 1:d5452e398b76 370 // FALSE if 'timeout' expires or the message length is wrong
Just4pLeisure 1:d5452e398b76 371 //
Just4pLeisure 1:d5452e398b76 372 extern bool can_send_timeout (uint32_t id, char *frame, uint8_t len, uint16_t timeout) {
Just4pLeisure 1:d5452e398b76 373 CANTimer.reset();
Just4pLeisure 1:d5452e398b76 374 CANTimer.start();
Just4pLeisure 1:d5452e398b76 375 while (CANTimer.read_ms() < timeout) {
Just4pLeisure 1:d5452e398b76 376 if (can.write(CANMessage(id, frame, len))) {
Just4pLeisure 1:d5452e398b76 377 CANTimer.stop();
Just4pLeisure 2:bf3a2b29259a 378 CANTXLEDON;
Just4pLeisure 2:bf3a2b29259a 379 // led1 = 1;
Just4pLeisure 1:d5452e398b76 380 return TRUE;
Just4pLeisure 1:d5452e398b76 381 }
Just4pLeisure 1:d5452e398b76 382 }
Just4pLeisure 1:d5452e398b76 383 can.reset();
Just4pLeisure 1:d5452e398b76 384 CANTimer.stop();
Just4pLeisure 1:d5452e398b76 385 return FALSE;
Just4pLeisure 1:d5452e398b76 386 }
Just4pLeisure 1:d5452e398b76 387
Just4pLeisure 1:d5452e398b76 388 //
Just4pLeisure 1:d5452e398b76 389 // Waits for a CAN Message with the specified 'id' for a time specified by the 'timeout'
Just4pLeisure 1:d5452e398b76 390 // All other messages are ignored
Just4pLeisure 1:d5452e398b76 391 // The CAN message frame is returned using the pointer to 'frame'
Just4pLeisure 1:d5452e398b76 392 //
Just4pLeisure 1:d5452e398b76 393 // inputs: integer CAN message 'id', pointer to 'frame' for returning the data
Just4pLeisure 1:d5452e398b76 394 // integer expected length of message, len and integer for the waiting time 'timeout'
Just4pLeisure 1:d5452e398b76 395 //
Just4pLeisure 1:d5452e398b76 396 // return: TRUE if a qualifying message was received
Just4pLeisure 1:d5452e398b76 397 // FALSE if 'timeout' expires or the message length is wrong
Just4pLeisure 1:d5452e398b76 398 //
Just4pLeisure 1:d5452e398b76 399 extern bool can_wait_timeout (uint32_t id, char *frame, uint8_t len, uint16_t timeout) {
Just4pLeisure 1:d5452e398b76 400 CANMessage CANMsgRx;
Just4pLeisure 1:d5452e398b76 401 CANTimer.reset();
Just4pLeisure 1:d5452e398b76 402 CANTimer.start();
Just4pLeisure 1:d5452e398b76 403 while (CANTimer.read_ms() < timeout) {
Just4pLeisure 1:d5452e398b76 404 if (can.read(CANMsgRx)) {
Just4pLeisure 4:682d96ff6d79 405 /*
Just4pLeisure 4:682d96ff6d79 406 printf("w%03x8", CANMsgRx.id);
Just4pLeisure 4:682d96ff6d79 407 for (char i=0; i<len; i++) {
Just4pLeisure 4:682d96ff6d79 408 printf("%02x", CANMsgRx.data[i]);
Just4pLeisure 4:682d96ff6d79 409 }
Just4pLeisure 4:682d96ff6d79 410 printf("\n\r");
Just4pLeisure 4:682d96ff6d79 411 // */
Just4pLeisure 2:bf3a2b29259a 412 CANRXLEDON;
Just4pLeisure 2:bf3a2b29259a 413 // led2 = 1;
Just4pLeisure 4:682d96ff6d79 414 if (CANMsgRx.id == id || id ==0) {
Just4pLeisure 1:d5452e398b76 415 CANTimer.stop();
Just4pLeisure 1:d5452e398b76 416 // if (T5MsgRx.len != len)
Just4pLeisure 1:d5452e398b76 417 // return FALSE;
Just4pLeisure 1:d5452e398b76 418 for (int i=0; i<len; i++)
Just4pLeisure 1:d5452e398b76 419 frame[i] = CANMsgRx.data[i];
Just4pLeisure 1:d5452e398b76 420 return TRUE;
Just4pLeisure 1:d5452e398b76 421 }
Just4pLeisure 1:d5452e398b76 422 }
Just4pLeisure 1:d5452e398b76 423 }
Just4pLeisure 1:d5452e398b76 424 can.reset();
Just4pLeisure 1:d5452e398b76 425 CANTimer.stop();
Just4pLeisure 1:d5452e398b76 426 return FALSE;
Just4pLeisure 1:d5452e398b76 427 }