Tick Tock / Mbed 2 deprecated CANary_9341

Dual CANbus monitor and instrumentation cluster supporting ILI9341 display controller

Dependencies:   SPI_TFTx2_ILI9341 TOUCH_TFTx2_ILI9341 TFT_fonts mbed

Fork of CANary by Tick Tock

utility.cpp@189:439e113fec1c, 2014-05-17 (annotated)

Committer:
TickTock
Date:
Sat May 17 13:53:16 2014 +0000
Revision:
189:439e113fec1c
Parent:
175:0357b4159b40 
renamed libraries to avoid conflict with originals

Who changed what in which revision?

UserRevisionLine numberNew contents of line
TickTock 13:62e0f7f39ff5 1 // utility.cpp
TickTock 13:62e0f7f39ff5 2 #include "utility.h"
TickTock 174:cd27e80f197d 3 unsigned long brkMonRate = 378947;
TickTock 174:cd27e80f197d 4 unsigned short brkMonThr = 1895;
TickTock 155:f31006516956 5 Timeout beepOff;
TickTock 160:905fe45ed54b 6 unsigned char bCount = 2;
TickTock 160:905fe45ed54b 7 float bFreq[2] = { 1000, 1000 };
TickTock 160:905fe45ed54b 8 float bTime[2] = { 0.1, 0.1 };
TickTock 13:62e0f7f39ff5 9
TickTock 13:62e0f7f39ff5 10 void mbed_reset();
TickTock 22:a43df3905863 11
TickTock 13:62e0f7f39ff5 12 void RTC_IRQHandler() {
TickTock 13:62e0f7f39ff5 13 timer.reset(); // zero ms at the-seconds-tic
TickTock 131:0d926c080a65 14 carCanIdle=(++secsNoCarCanMsg>canTimeout)?true:false;
TickTock 132:08748a67280a 15 evCanIdle=(++secsNoEvCanMsg>canTimeout)?true:false;
TickTock 20:3bf176d14b14 16 userIdle=(++secsNoTouch>userTimeout)?true:false;
TickTock 13:62e0f7f39ff5 17 LPC_RTC->ILR |= (1<<0); // clear interrupt to prepare for next
TickTock 34:4751a8259b18 18 tick=true;
garygid 69:6bfdfc002036 19 // will use this to generate a logTP() just before the next Message received.
garygid 69:6bfdfc002036 20 if( (time(NULL) % 60) == 0) ZeroSecTick = true; // gg - at 0-second of each minute
TickTock 13:62e0f7f39ff5 21 }
TickTock 13:62e0f7f39ff5 22
TickTock 37:fea2c1d52c5f 23 void RTC_Init (void) {
TickTock 13:62e0f7f39ff5 24 LPC_RTC->ILR=0x00; // set up the RTC interrupts
TickTock 13:62e0f7f39ff5 25 LPC_RTC->CIIR=0x01; // interrupts each second
TickTock 13:62e0f7f39ff5 26 LPC_RTC->CCR = 0x01; // Clock enable
TickTock 13:62e0f7f39ff5 27 //NVIC_SetPriority( RTC_IRQn, 10 );
TickTock 13:62e0f7f39ff5 28 NVIC_EnableIRQ( RTC_IRQn );
TickTock 13:62e0f7f39ff5 29 }
TickTock 13:62e0f7f39ff5 30
TickTock 93:c2402e8cd0e2 31 void printMsg (char *msg) {
TickTock 13:62e0f7f39ff5 32 strcpy(displayLog[displayLoc],msg);
TickTock 13:62e0f7f39ff5 33 displayLoc=displayLoc>17?0:displayLoc+1;
TickTock 13:62e0f7f39ff5 34 }
TickTock 13:62e0f7f39ff5 35
TickTock 13:62e0f7f39ff5 36 void touch_ISR(){
TickTock 138:a2f5af85ed0d 37 //LPC_GPIOINT->IO2IntClr = (LPC_GPIOINT->IO2IntStatR | LPC_GPIOINT->IO2IntStatF); // seems to work without so maybe not necessary (performed in InterruptIn handler?)
TickTock 35:5acbd8a64a89 38 touched=true; // just set flag - touch screen algorythm is long and we don't want to block other interrupts
TickTock 13:62e0f7f39ff5 39 }
TickTock 13:62e0f7f39ff5 40
TickTock 13:62e0f7f39ff5 41 unsigned short getTimeStamp() {
TickTock 13:62e0f7f39ff5 42 unsigned short msec = timer.read_ms() ; // read ms from the timer
TickTock 13:62e0f7f39ff5 43 unsigned long secs = time(NULL); // seconds past 12:00:00 AM 1 Jan 1900
TickTock 13:62e0f7f39ff5 44 unsigned short isecs = secs%60 ; // modulo 60 for 0-59 seconds from RTC
TickTock 13:62e0f7f39ff5 45 return ((isecs<<10)+msec) ; // return the two byte time stamp
TickTock 13:62e0f7f39ff5 46 }
TickTock 13:62e0f7f39ff5 47
TickTock 13:62e0f7f39ff5 48 void logCan (char mType, CANMessage canRXmsg) {
TickTock 85:5c27e88b3fbe 49
TickTock 85:5c27e88b3fbe 50 static unsigned char ii = 0;
TickTock 85:5c27e88b3fbe 51 static unsigned char lasti = 0; // indexindex
TickTock 37:fea2c1d52c5f 52 static unsigned char bdi=0;
TickTock 174:cd27e80f197d 53 static signed short imotorRPM = 0;
TickTock 85:5c27e88b3fbe 54 static unsigned short nLost = 0; // gg - overrun
TickTock 85:5c27e88b3fbe 55
TickTock 83:52b1f330a62d 56 char sTemp[40];
TickTock 92:935adef49ea4 57 unsigned char changed;
TickTock 108:29b5a760adc2 58 unsigned short i,j,k;
TickTock 119:0e2b641e98a2 59 signed short packV_x2;
TickTock 119:0e2b641e98a2 60 signed short packA_x2;
TickTock 40:0e6e71a7323f 61 signed long imWs_x4;
garygid 87:46ac3f2519d6 62 unsigned short ts;
TickTock 85:5c27e88b3fbe 63
garygid 87:46ac3f2519d6 64 if(debugMode||(skin==ggSkin)){
TickTock 161:71ac85d11f03 65 // code to insert actual number of dropped frames for overrun debug - skipped in normal mode to keep logcan short
TickTock 85:5c27e88b3fbe 66 if(logOpen){
TickTock 106:f016912a03db 67 // check to see if buffer is already full (read - write) = 1
TickTock 106:f016912a03db 68 // actually the last buffer location cannot be used because then
TickTock 106:f016912a03db 69 // the buffer would look empty after writePointer++
TickTock 106:f016912a03db 70
TickTock 106:f016912a03db 71 //if (((writePointer+maxBufLen-readPointer)%maxBufLen)>(maxBufLen/16)) // modulo is slow?
TickTock 106:f016912a03db 72
TickTock 106:f016912a03db 73 // pointers are 0 through maxBufLen-1
TickTock 106:f016912a03db 74 if( (readPointer - writePointer) == 1 || (writePointer - readPointer) == (maxBufLen - 1)) {
TickTock 106:f016912a03db 75 // the buffer is "full", so Lose this message
TickTock 85:5c27e88b3fbe 76
TickTock 106:f016912a03db 77 // point to the last-stored message
TickTock 106:f016912a03db 78 int tempWritePointer = writePointer - 1 ;
TickTock 106:f016912a03db 79 if( tempWritePointer < 0 ) tempWritePointer = maxBufLen - 1;
TickTock 106:f016912a03db 80 char strLost[9] ;
TickTock 106:f016912a03db 81
TickTock 106:f016912a03db 82 if( nLost == 0 ) {
TickTock 106:f016912a03db 83 // this is the first message lost
TickTock 106:f016912a03db 84 // and we must overwrite the last message with an FFE comment message
TickTock 106:f016912a03db 85 // So, there will be two messages lost as the comment message is laid in.
TickTock 106:f016912a03db 86 nLost = 2;
TickTock 106:f016912a03db 87 sprintf(strLost,"%s","Lost0002"); // indicate two messages lost
TickTock 85:5c27e88b3fbe 88
TickTock 106:f016912a03db 89 // overlay the last message with a "Lost0002" comment
TickTock 106:f016912a03db 90 writeBuffer[tempWritePointer][0]=0;
TickTock 117:49883c779a74 91 // leave the ts of the overlaid message
TickTock 117:49883c779a74 92 //writeBuffer[tempWritePointer][1]=(ts&0xff00)>>8; // Time Stamp (2 bytes_
TickTock 117:49883c779a74 93 //writeBuffer[tempWritePointer][2]=(ts&0x00ff);
TickTock 106:f016912a03db 94 // force the MsgID to an Event Message
TickTock 106:f016912a03db 95 writeBuffer[tempWritePointer][3]=0xfe; // MsgID, low byte
TickTock 106:f016912a03db 96 writeBuffer[tempWritePointer][4]=0xff; // Len nibble, and MsgID high nibble
TickTock 106:f016912a03db 97 // lay in the "Lost0002" text
TickTock 106:f016912a03db 98 for(i=5;i<13;i++){
TickTock 106:f016912a03db 99 writeBuffer[tempWritePointer][i]= strLost[i-5];
TickTock 85:5c27e88b3fbe 100 }
TickTock 85:5c27e88b3fbe 101 } else {
TickTock 106:f016912a03db 102 // at least one message was previously lost
TickTock 106:f016912a03db 103 // increment the loat counter
TickTock 106:f016912a03db 104 nLost += 1;
garygid 87:46ac3f2519d6 105
TickTock 106:f016912a03db 106 // lay the new count into the comment
TickTock 106:f016912a03db 107 sprintf(strLost,"%04d",nLost);
TickTock 106:f016912a03db 108 for(i=9;i<13;i++){
TickTock 106:f016912a03db 109 writeBuffer[tempWritePointer][i]= strLost[i-9];
TickTock 85:5c27e88b3fbe 110 }
TickTock 106:f016912a03db 111 }
TickTock 106:f016912a03db 112 } else {
TickTock 106:f016912a03db 113 // there is room to insert the message
TickTock 106:f016912a03db 114 // get it inserted quickly
TickTock 106:f016912a03db 115 ts=getTimeStamp();
TickTock 106:f016912a03db 116 writeBuffer[writePointer][0]=mType;
TickTock 106:f016912a03db 117 writeBuffer[writePointer][1]=(ts&0xff00)>>8; // Time Stamp (2 bytes_
TickTock 106:f016912a03db 118 writeBuffer[writePointer][2]=(ts&0x00ff);
TickTock 106:f016912a03db 119 writeBuffer[writePointer][3]=canRXmsg.id&0xff; // MsgID, low byte
TickTock 106:f016912a03db 120 char sLen = canRXmsg.len ;
TickTock 106:f016912a03db 121 writeBuffer[writePointer][4]=(canRXmsg.id>>8)+(sLen<<4); // Len nibble, and MsgID high nibble
TickTock 106:f016912a03db 122 for(i=0;i<8;i++){ // Is there a better way to do this? (writeBuffer[writePointer][i]=canRXmsg.data?)
TickTock 106:f016912a03db 123 if(i<sLen)
TickTock 106:f016912a03db 124 writeBuffer[writePointer][i+5]=canRXmsg.data[i];
TickTock 106:f016912a03db 125 else // i>=sLen
TickTock 106:f016912a03db 126 // force unused data bytes to FF for CAN-Do compatibility
TickTock 106:f016912a03db 127 writeBuffer[writePointer][i+5]=0xFF;
TickTock 85:5c27e88b3fbe 128 }
TickTock 106:f016912a03db 129
TickTock 106:f016912a03db 130 //--------------
TickTock 106:f016912a03db 131 // Note, this is not protected from the interrupt.
TickTock 106:f016912a03db 132 // Due to the nLost code above, this no longer
TickTock 106:f016912a03db 133 // overflows to writePointer = readPointer
TickTock 106:f016912a03db 134 // which would make the buffer look empty
TickTock 106:f016912a03db 135 if (++writePointer >= maxBufLen) {
TickTock 106:f016912a03db 136 writePointer = 0;
TickTock 106:f016912a03db 137 led3 = !led3;
TickTock 106:f016912a03db 138 }
TickTock 106:f016912a03db 139 //--------------
TickTock 106:f016912a03db 140 // log a local message if we had lost messages. gg - logcan
TickTock 106:f016912a03db 141 if( nLost > 0 ) {
TickTock 106:f016912a03db 142 // We previously lost messages that did not get into the buffer
TickTock 106:f016912a03db 143 sprintf(sTemp,"-- Lost %d Messages.\n", nLost);
TickTock 106:f016912a03db 144 printMsg(sTemp); // write buffer overrun
TickTock 156:4e5d30535cf9 145 beep(500,0.25);
TickTock 106:f016912a03db 146
TickTock 106:f016912a03db 147 nLost = 0 ;
TickTock 106:f016912a03db 148 }
TickTock 106:f016912a03db 149 //--------------
TickTock 13:62e0f7f39ff5 150 }
TickTock 85:5c27e88b3fbe 151 }
TickTock 92:935adef49ea4 152 }else{ // not debugMode - keep code short
TickTock 85:5c27e88b3fbe 153 if(logOpen){
TickTock 106:f016912a03db 154 NVIC_DisableIRQ(CAN_IRQn); // Block interrupts until write pointer assigned
TickTock 106:f016912a03db 155 int localWritePointer = writePointer++; // create local copy to make logCan reentrant
TickTock 106:f016912a03db 156 // note that the static variables do not prevent safe reentry
TickTock 106:f016912a03db 157 // since they are only used for msgId<0x800 which will never interrupt
TickTock 106:f016912a03db 158 // another msgId<0x800 (both CANbusses are same priority)
TickTock 106:f016912a03db 159 if (writePointer >= maxBufLen) {
TickTock 77:7c136766466c 160 writePointer = 0;
TickTock 77:7c136766466c 161 led3 = !led3;
TickTock 77:7c136766466c 162 }
TickTock 106:f016912a03db 163 NVIC_EnableIRQ(CAN_IRQn); // Unblock interrupts once local pointer set and global pointer incremented
TickTock 106:f016912a03db 164 ts=getTimeStamp();
TickTock 106:f016912a03db 165 writeBuffer[localWritePointer][0]=mType;
TickTock 106:f016912a03db 166 writeBuffer[localWritePointer][1]=(ts&0xff00)>>8;
TickTock 106:f016912a03db 167 writeBuffer[localWritePointer][2]=(ts&0x00ff);
TickTock 106:f016912a03db 168 writeBuffer[localWritePointer][3]=canRXmsg.id&0xff;
TickTock 106:f016912a03db 169 writeBuffer[localWritePointer][4]=(canRXmsg.id>>8)+(canRXmsg.len<<4);
TickTock 161:71ac85d11f03 170 for(i=5;i<13;i++){ // Is there a better way to do this?
TickTock 106:f016912a03db 171 writeBuffer[localWritePointer][i]=canRXmsg.data[i-5];
TickTock 106:f016912a03db 172 }
TickTock 75:77bd26829dca 173 if (writePointer==readPointer) {
TickTock 117:49883c779a74 174 // Just caught up to read pointer
TickTock 117:49883c779a74 175 printMsg("Write buffer overrun.\n"); // write buffer overrun
TickTock 156:4e5d30535cf9 176 //beep(500,0.25);
TickTock 13:62e0f7f39ff5 177 }
TickTock 13:62e0f7f39ff5 178 }
TickTock 37:fea2c1d52c5f 179 }
TickTock 40:0e6e71a7323f 180
TickTock 83:52b1f330a62d 181 if(canRXmsg.id<0x800){ // Block FFE and FFF messages
TickTock 83:52b1f330a62d 182 if(indexLastMsg[canRXmsg.id]==0) { //Check if no entry
garygid 87:46ac3f2519d6 183 if(ii<99) {
garygid 87:46ac3f2519d6 184 indexLastMsg[canRXmsg.id]=++ii; //Create entry for first MsgID occurance
garygid 87:46ac3f2519d6 185 // ii max is 99 here
garygid 87:46ac3f2519d6 186 } else {
garygid 87:46ac3f2519d6 187 // the ii array is full, more than 100 MsgIDs found
garygid 87:46ac3f2519d6 188 if(ii==99) {
TickTock 92:935adef49ea4 189 ii++; // step to 100 to log only one error
TickTock 161:71ac85d11f03 190 printMsg("msgID buffer overrun.\n");
TickTock 161:71ac85d11f03 191 beep3(500,0.25,1000,0.5,500,0.25); //Alert driver to check log
garygid 87:46ac3f2519d6 192 }
TickTock 13:62e0f7f39ff5 193 }
TickTock 13:62e0f7f39ff5 194 }
TickTock 161:71ac85d11f03 195 lastMsg[indexLastMsg[canRXmsg.id]]=canRXmsg; //Store data in table at assigned index
garygid 87:46ac3f2519d6 196
garygid 87:46ac3f2519d6 197 //----------------
TickTock 85:5c27e88b3fbe 198 if(dMode[0]==changedScreen||dMode[1]==changedScreen){// Skip if not using (for execution speed)
TickTock 83:52b1f330a62d 199 changed=msgChanged[indexLastMsg[canRXmsg.id]];
TickTock 85:5c27e88b3fbe 200 // This is cleared in the main loop when reset button is touched
TickTock 92:935adef49ea4 201 for(i=0;i<8;i++){
TickTock 83:52b1f330a62d 202 if(lastMsg[indexLastMsg[canRXmsg.id]].data[i]!=canRXmsg.data[i]){
TickTock 83:52b1f330a62d 203 changed |= 1<<i;
garygid 80:24f1793171e7 204 }
TickTock 13:62e0f7f39ff5 205 }
TickTock 83:52b1f330a62d 206 msgChanged[indexLastMsg[canRXmsg.id]]=changed;
TickTock 13:62e0f7f39ff5 207 }
garygid 87:46ac3f2519d6 208
garygid 87:46ac3f2519d6 209 //-------------------
TickTock 83:52b1f330a62d 210 //Miscellaneous on-recieve operations below
TickTock 124:0d622967b764 211 if((mType==1)&&(canRXmsg.id==0x7bb)){ // is battery data? Need to store all responses
TickTock 124:0d622967b764 212 if(canRXmsg.data[0]<0x20){
TickTock 115:549410af477d 213 if(canRXmsg.data[3]==1){//Group 1 data
TickTock 124:0d622967b764 214 bdi=BatDataBaseG1; // index offset for Group 1 data
TickTock 115:549410af477d 215 if(debugMode){
TickTock 116:5cd72bae7c12 216 printMsg(" Getting Group 1 data\n");
TickTock 115:549410af477d 217 }
TickTock 115:549410af477d 218
TickTock 115:549410af477d 219 }else if(canRXmsg.data[3]==2){//Group 2 = cellpair data
TickTock 124:0d622967b764 220 bdi=BatDataBaseG2; // index offset for CP data
TickTock 97:a25940fd7b5b 221 if(debugMode){
TickTock 116:5cd72bae7c12 222 printMsg(" Getting cell pair data\n");
TickTock 97:a25940fd7b5b 223 }
garygid 87:46ac3f2519d6 224
TickTock 115:549410af477d 225 }else if(canRXmsg.data[3]==3){//Group 3 data
TickTock 124:0d622967b764 226 bdi=BatDataBaseG3; // index offset for Group 3 data
TickTock 115:549410af477d 227 if(debugMode){
TickTock 116:5cd72bae7c12 228 printMsg(" Getting Group 3 data\n");
TickTock 115:549410af477d 229 }
TickTock 115:549410af477d 230
garygid 87:46ac3f2519d6 231 }else if(canRXmsg.data[3]==4){//Group 4 = temperature data
TickTock 124:0d622967b764 232 bdi=BatDataBaseG4; // index offset for Temperature data
TickTock 97:a25940fd7b5b 233 if(debugMode){
TickTock 116:5cd72bae7c12 234 printMsg(" Getting temperature data\n");
TickTock 97:a25940fd7b5b 235 }
garygid 87:46ac3f2519d6 236
garygid 87:46ac3f2519d6 237 }else if(canRXmsg.data[3]==5){//Group 5 data
TickTock 124:0d622967b764 238 bdi=BatDataBaseG5; // index offset for Group 5 data
TickTock 97:a25940fd7b5b 239 if(debugMode){
TickTock 116:5cd72bae7c12 240 printMsg(" Getting Group 5 data\n");
TickTock 97:a25940fd7b5b 241 }
garygid 87:46ac3f2519d6 242
TickTock 121:553faf139a20 243 }else if(canRXmsg.data[3]==6){//Group 6 data = shunt data
TickTock 124:0d622967b764 244 bdi=BatDataBaseG6; // index offset for Group 6 data
TickTock 121:553faf139a20 245 if(debugMode){
TickTock 121:553faf139a20 246 printMsg(" Getting Group 6 data\n");
TickTock 121:553faf139a20 247 }
TickTock 121:553faf139a20 248
TickTock 83:52b1f330a62d 249 }else bdi=0xff; // ignore other messages (for now)
TickTock 83:52b1f330a62d 250 lasti=0;
TickTock 83:52b1f330a62d 251 }
garygid 87:46ac3f2519d6 252
TickTock 83:52b1f330a62d 253 if(bdi<0xff){
TickTock 83:52b1f330a62d 254 i=canRXmsg.data[0]&0x0f; //lower nibble of D0 is index
TickTock 83:52b1f330a62d 255 if(lasti>i){ //detect rollover and offset index appropriately
TickTock 115:549410af477d 256 bdi += 0x10; // for CP data
TickTock 83:52b1f330a62d 257 }
TickTock 83:52b1f330a62d 258 lasti=i; //remember the msb to detect rollover next time around
TickTock 83:52b1f330a62d 259 i+=bdi;
garygid 87:46ac3f2519d6 260 //-------
TickTock 121:553faf139a20 261 //-------
TickTock 121:553faf139a20 262 i*=7;
TickTock 124:0d622967b764 263 if(i+6 < BatDataBufMax) {
TickTock 124:0d622967b764 264 battData[i+0]=canRXmsg.data[1];
TickTock 124:0d622967b764 265 battData[i+1]=canRXmsg.data[2];
TickTock 124:0d622967b764 266 battData[i+2]=canRXmsg.data[3];
TickTock 124:0d622967b764 267 battData[i+3]=canRXmsg.data[4];
TickTock 124:0d622967b764 268 battData[i+4]=canRXmsg.data[5];
TickTock 124:0d622967b764 269 battData[i+5]=canRXmsg.data[6];
TickTock 124:0d622967b764 270 battData[i+6]=canRXmsg.data[7];
TickTock 121:553faf139a20 271 }
TickTock 124:0d622967b764 272 if(i==(BatDataBaseG6+3)*7){ // All data loaded
TickTock 83:52b1f330a62d 273 logCP=yesBattLog; // Only log if logging enabled
TickTock 83:52b1f330a62d 274 showCP=true; // Always show
TickTock 121:553faf139a20 275
TickTock 121:553faf139a20 276 // Find hottest temperature by finding smallest ADC value
TickTock 102:fd19f777a0b4 277 // 2013 models only have three sensors
TickTock 124:0d622967b764 278 k=battData[(BatDataBaseG4*7)+3]*0x100+battData[(BatDataBaseG4*7)+4];
TickTock 124:0d622967b764 279 j=battData[(BatDataBaseG4*7)+6]*0x100+battData[(BatDataBaseG4*7)+7];
TickTock 115:549410af477d 280 if(j<k)k=j;
TickTock 124:0d622967b764 281 j=battData[(BatDataBaseG4*7)+9]*0x100+battData[(BatDataBaseG4*7)+10];
TickTock 115:549410af477d 282 if(j<k)k=j;
TickTock 124:0d622967b764 283 j=battData[(BatDataBaseG4*7)+12]*0x100+battData[(BatDataBaseG4*7)+13];
TickTock 115:549410af477d 284 if(j<k)k=j;
TickTock 108:29b5a760adc2 285 //interpolate from lookup table
TickTock 175:0357b4159b40 286 unsigned short temp_adc[10] = {1000,720,690,589,487,401,365,340,309,000};
TickTock 175:0357b4159b40 287 float temp_C[10] = { -27, 0, 3, 13, 23, 32, 36, 39, 43, 76};
TickTock 108:29b5a760adc2 288 char ii=0;
TickTock 108:29b5a760adc2 289 while(k<=temp_adc[++ii]) { } // Find section in table
TickTock 108:29b5a760adc2 290 maxTemp=(float)(k-temp_adc[ii]);
TickTock 108:29b5a760adc2 291 maxTemp/=(float)(temp_adc[ii-1]-temp_adc[ii]);
TickTock 108:29b5a760adc2 292 maxTemp*=(temp_C[ii-1]-temp_C[ii]);
TickTock 108:29b5a760adc2 293 maxTemp+=temp_C[ii];
TickTock 41:8d4609ea7259 294
TickTock 121:553faf139a20 295 // Get state of health
TickTock 143:88b5155622a5 296 SOH2_x100=battData[(BatDataBaseG1*7)+29]*0x100+battData[(BatDataBaseG1*7)+30];
TickTock 124:0d622967b764 297 Ah_x10000=battData[(BatDataBaseG1*7)+36]*0x10000+battData[(BatDataBaseG1*7)+37]*0x100+battData[(BatDataBaseG1*7)+38];
TickTock 124:0d622967b764 298 SOC_x10000=battData[(BatDataBaseG1*7)+32]*0x10000+battData[(BatDataBaseG1*7)+33]*0x100+battData[(BatDataBaseG1*7)+34];
TickTock 143:88b5155622a5 299 accV2=(float)battData[(BatDataBaseG1*7)+23]/4+(float)battData[(BatDataBaseG1*7)+24]/1024;
TickTock 121:553faf139a20 300
TickTock 121:553faf139a20 301 // Save shunt data
TickTock 121:553faf139a20 302 for(j=0; j<24; j++){
TickTock 124:0d622967b764 303 shunt[j*4+0]=battData[BatDataBaseG6*7+j+3]&0x08;
TickTock 124:0d622967b764 304 shunt[j*4+1]=battData[BatDataBaseG6*7+j+3]&0x04;
TickTock 124:0d622967b764 305 shunt[j*4+2]=battData[BatDataBaseG6*7+j+3]&0x02;
TickTock 124:0d622967b764 306 shunt[j*4+3]=battData[BatDataBaseG6*7+j+3]&0x01;
TickTock 121:553faf139a20 307 }
TickTock 83:52b1f330a62d 308 }
TickTock 83:52b1f330a62d 309 }
TickTock 83:52b1f330a62d 310 }else if((mType==1)&&(canRXmsg.id==0x1db)){ //Battery Volts and Amps
TickTock 119:0e2b641e98a2 311 packV_x2=((canRXmsg.data[2]<<2)|(canRXmsg.data[3]>>6)); // 1 LSB = 0.5V
TickTock 119:0e2b641e98a2 312 packA_x2=((canRXmsg.data[0]<<3)|(canRXmsg.data[1]>>5)); // 1 LSB = 0.5A
TickTock 119:0e2b641e98a2 313 if(packA_x2>0x03ff){
TickTock 119:0e2b641e98a2 314 packA_x2|=0xf800;//extend sign;
TickTock 83:52b1f330a62d 315 }
TickTock 159:577e9d015693 316 packA_x2 -= 2; //Slight correction to value required (unique to my Leaf?)
TickTock 121:553faf139a20 317 if (-packA_x2<Imin){
TickTock 121:553faf139a20 318 Imin=-packA_x2;
TickTock 121:553faf139a20 319 } else if (-packA_x2>Imax){
TickTock 121:553faf139a20 320 Imax=-packA_x2;
TickTock 121:553faf139a20 321 }
TickTock 119:0e2b641e98a2 322 imWs_x4 = packV_x2; // Volts*milliSeconds*2
TickTock 119:0e2b641e98a2 323 imWs_x4 *= -packA_x2; // milliWattseconds*4
TickTock 118:02010b18efdc 324 mWs_x4 += imWs_x4; // total mWs_x4
TickTock 121:553faf139a20 325 float temp;
TickTock 121:553faf139a20 326 temp = Resr;
TickTock 121:553faf139a20 327 temp *= (float) -packA_x2;
TickTock 121:553faf139a20 328 temp += (float) packV_x2;
TickTock 120:041edeec08f5 329 if(temp>curRmax){
TickTock 120:041edeec08f5 330 curRmax=temp;
TickTock 120:041edeec08f5 331 } else if(temp<curRmin){
TickTock 120:041edeec08f5 332 curRmin=temp;
TickTock 120:041edeec08f5 333 }
TickTock 121:553faf139a20 334 temp = Resr-0.001;
TickTock 121:553faf139a20 335 temp *= (float) -packA_x2;
TickTock 121:553faf139a20 336 temp += (float) packV_x2;
TickTock 120:041edeec08f5 337 if(temp>redRmax){
TickTock 120:041edeec08f5 338 redRmax=temp;
TickTock 120:041edeec08f5 339 } else if(temp<redRmin){
TickTock 120:041edeec08f5 340 redRmin=temp;
TickTock 120:041edeec08f5 341 }
TickTock 121:553faf139a20 342 temp = Resr+0.001;
TickTock 121:553faf139a20 343 temp *= (float) -packA_x2;
TickTock 121:553faf139a20 344 temp += (float) packV_x2;
TickTock 120:041edeec08f5 345 if(temp>incRmax){
TickTock 120:041edeec08f5 346 incRmax=temp;
TickTock 120:041edeec08f5 347 } else if(temp<incRmin){
TickTock 120:041edeec08f5 348 incRmin=temp;
TickTock 120:041edeec08f5 349 }
TickTock 118:02010b18efdc 350 numWsamples++;
TickTock 174:cd27e80f197d 351 }else if((mType==2)&&(canRXmsg.id==0x176)){ //Motor Speed
TickTock 174:cd27e80f197d 352 imotorRPM=((canRXmsg.data[2]<<8)|(canRXmsg.data[3]));
TickTock 174:cd27e80f197d 353 motorRPM+=imotorRPM;
TickTock 92:935adef49ea4 354 numSsamples++;
TickTock 174:cd27e80f197d 355 // }else if((mType==1)&&(canRXmsg.id==0x1da)){ //Motor Speed
TickTock 174:cd27e80f197d 356 // imotorRPM_x2=((canRXmsg.data[4]<<8)|(canRXmsg.data[5]));
TickTock 174:cd27e80f197d 357 // if(imotorRPM_x2<0){ // take absolute value
TickTock 174:cd27e80f197d 358 // imotorRPM_x2=-imotorRPM_x2;
TickTock 174:cd27e80f197d 359 // }
TickTock 174:cd27e80f197d 360 // motorRPM_x2+=imotorRPM_x2;
TickTock 174:cd27e80f197d 361 // numSsamples++;
TickTock 148:6e3b9135fad2 362 // }else if((mType==2)&&(canRXmsg.id==0x1ca)){ //Brake Pressure
TickTock 148:6e3b9135fad2 363 }else if((mType==2)&&(canRXmsg.id==0x292)){ //Brake Pressure
TickTock 140:ab3e94eb0227 364 if(brakeMon){
TickTock 140:ab3e94eb0227 365 if(canRXmsg.data[0]<0xff){
TickTock 174:cd27e80f197d 366 if((canRXmsg.data[6]*imotorRPM)<brkMonThr){ // brkMonThr = 3.6/.0019 = 1895 --> squelch threshold 1Wh/sec
TickTock 140:ab3e94eb0227 367 chirpInt=0;
TickTock 174:cd27e80f197d 368 }else{ // imotorRPM*data[6]*.0019=kW; 3.6/kW = seconds until 1Wh;
TickTock 174:cd27e80f197d 369 chirpInt=brkMonRate/imotorRPM; // brkMonRate=3.6/.0019/.02=94736.8 --> 1 chirp per Wh
TickTock 148:6e3b9135fad2 370 chirpInt/=canRXmsg.data[6];
TickTock 140:ab3e94eb0227 371 }
TickTock 140:ab3e94eb0227 372 }
TickTock 140:ab3e94eb0227 373 }
TickTock 13:62e0f7f39ff5 374 }
TickTock 37:fea2c1d52c5f 375 }
TickTock 13:62e0f7f39ff5 376 }
TickTock 13:62e0f7f39ff5 377
garygid 87:46ac3f2519d6 378 //-----------------------------
TickTock 13:62e0f7f39ff5 379 void logTS () {
TickTock 13:62e0f7f39ff5 380 CANMessage tsMsg;
TickTock 13:62e0f7f39ff5 381 unsigned long secs = time(NULL); // seconds past 12:00:00 AM 1 Jan 1900
garygid 69:6bfdfc002036 382 // NOTE: In Mbed, I believe that this is seconds past start of 1970, not 1900
garygid 69:6bfdfc002036 383 // but this is good, since seconds past 1970 is what CAN-Do expects. GG - Date Time
TickTock 13:62e0f7f39ff5 384 tsMsg.id=0xfff;
TickTock 13:62e0f7f39ff5 385 tsMsg.len=0xf;
garygid 69:6bfdfc002036 386 tsMsg.data[0]=secs&0xff;
TickTock 13:62e0f7f39ff5 387 tsMsg.data[1]=(secs>>8)&0xff;
TickTock 13:62e0f7f39ff5 388 tsMsg.data[2]=(secs>>16)&0xff;
garygid 69:6bfdfc002036 389 tsMsg.data[3]=(secs>>24)&0xff;
garygid 69:6bfdfc002036 390 tsMsg.data[4]=0; // 0xff; gg - Date Time
garygid 69:6bfdfc002036 391 tsMsg.data[5]=0; // 0xff; for CAN-Do
garygid 69:6bfdfc002036 392 tsMsg.data[6]=0; // 0xff;
TickTock 13:62e0f7f39ff5 393 tsMsg.data[7]=0xff;
garygid 69:6bfdfc002036 394 logCan(0,tsMsg); // Date-Time
garygid 69:6bfdfc002036 395 }
garygid 69:6bfdfc002036 396
TickTock 93:c2402e8cd0e2 397 void logEvent (char * errMsg) {
garygid 69:6bfdfc002036 398 // log CAN-Do 8-character Pseudo Message
garygid 69:6bfdfc002036 399 CANMessage tsMsg;
garygid 69:6bfdfc002036 400 tsMsg.id=0xffe; // pseudo Message to CAN-Do log
garygid 69:6bfdfc002036 401 tsMsg.len=0xf;
garygid 69:6bfdfc002036 402 int iMsgLen = strlen(errMsg);
garygid 69:6bfdfc002036 403 // 8 character message compatible with CAN-Do
garygid 69:6bfdfc002036 404 for(int i=0; i<8; i++){
garygid 69:6bfdfc002036 405 tsMsg.data[i]=' ';
garygid 69:6bfdfc002036 406 if( i < iMsgLen ) tsMsg.data[i]=errMsg[i];
garygid 69:6bfdfc002036 407 }
garygid 69:6bfdfc002036 408 logCan(0,tsMsg); // FFE Comment Message
TickTock 13:62e0f7f39ff5 409 }
TickTock 13:62e0f7f39ff5 410
TickTock 78:a383971fe02f 411 void sendReq() {
TickTock 78:a383971fe02f 412 static char data[8] = {0x02, 0x21, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff};
TickTock 78:a383971fe02f 413 if(reqMsgCnt<99){
TickTock 78:a383971fe02f 414 switch (reqMsgCnt){
TickTock 124:0d622967b764 415 case BatDataBaseG1:
TickTock 138:a2f5af85ed0d 416 can2.monitor(false); // set to active mode
TickTock 138:a2f5af85ed0d 417 can2SleepMode = 0; // enable TX
TickTock 79:68f0dd8d1f19 418 data[0]=0x02; //change to request group 1
TickTock 78:a383971fe02f 419 data[1]=0x21;
TickTock 78:a383971fe02f 420 data[2]=0x01;
TickTock 78:a383971fe02f 421 break;
TickTock 124:0d622967b764 422 case BatDataBaseG2: // group 1 has 6 frames
TickTock 79:68f0dd8d1f19 423 data[0]=0x02; //change to request group 2 (cp data)
TickTock 78:a383971fe02f 424 data[1]=0x21;
TickTock 78:a383971fe02f 425 data[2]=0x02;
TickTock 78:a383971fe02f 426 break;
TickTock 124:0d622967b764 427 case BatDataBaseG3: // group 2 has 29 frames
TickTock 79:68f0dd8d1f19 428 data[0]=0x02; //change to request group 3
TickTock 78:a383971fe02f 429 data[1]=0x21;
TickTock 78:a383971fe02f 430 data[2]=0x03;
TickTock 78:a383971fe02f 431 break;
TickTock 124:0d622967b764 432 case BatDataBaseG4: // group 3 has 5 frames
TickTock 79:68f0dd8d1f19 433 data[0]=0x02; //change to request group 4 (temperature)
TickTock 78:a383971fe02f 434 data[1]=0x21;
TickTock 78:a383971fe02f 435 data[2]=0x04;
TickTock 78:a383971fe02f 436 break;
TickTock 124:0d622967b764 437 case BatDataBaseG5: // group 4 has 3 frames
TickTock 79:68f0dd8d1f19 438 data[0]=0x02; //change to request group 5
TickTock 78:a383971fe02f 439 data[1]=0x21;
TickTock 78:a383971fe02f 440 data[2]=0x05;
TickTock 78:a383971fe02f 441 break;
TickTock 124:0d622967b764 442 case BatDataBaseG6: // group 4 has 3 frames
TickTock 124:0d622967b764 443 data[0]=0x02; //change to request group 5
TickTock 121:553faf139a20 444 data[1]=0x21;
TickTock 121:553faf139a20 445 data[2]=0x06;
TickTock 121:553faf139a20 446 break;
TickTock 124:0d622967b764 447 case BatDataBaseG7: // group 5 has 11 frames
TickTock 78:a383971fe02f 448 reqMsgCnt = 99;
TickTock 138:a2f5af85ed0d 449 can2SleepMode = VP230Sleep; // disable TX
TickTock 138:a2f5af85ed0d 450 can2.monitor(true); // set to snoop mode
TickTock 79:68f0dd8d1f19 451 msgReq.detach(); // stop ticker
TickTock 78:a383971fe02f 452 default:
TickTock 78:a383971fe02f 453 data[0]=0x30; //change to request next line message
TickTock 78:a383971fe02f 454 data[1]=0x01;
TickTock 78:a383971fe02f 455 data[2]=0x00;
TickTock 78:a383971fe02f 456 }
TickTock 138:a2f5af85ed0d 457 can2.write(CANMessage(0x79b, data, 8));
TickTock 78:a383971fe02f 458 reqMsgCnt++;
TickTock 78:a383971fe02f 459 }
TickTock 78:a383971fe02f 460 }
TickTock 78:a383971fe02f 461
TickTock 138:a2f5af85ed0d 462 void sendTempReq(){
TickTock 138:a2f5af85ed0d 463 //Requests ambient and cabin temperature
TickTock 138:a2f5af85ed0d 464 char data[8] = {0x03, 0x22, 0x11, 0x5d, 0xff, 0xff, 0xff, 0xff};
TickTock 138:a2f5af85ed0d 465 can2.monitor(false); // set to active mode
TickTock 138:a2f5af85ed0d 466 can2SleepMode = 0; // enable TX
TickTock 138:a2f5af85ed0d 467 can2.write(CANMessage(0x797, data, 8));
TickTock 138:a2f5af85ed0d 468 can2SleepMode = VP230Sleep; // disable TX
TickTock 138:a2f5af85ed0d 469 }
TickTock 138:a2f5af85ed0d 470
TickTock 78:a383971fe02f 471 void autoPollISR(){
TickTock 138:a2f5af85ed0d 472 //sendTempReq();
TickTock 78:a383971fe02f 473 reqMsgCnt = 0; //reset message counter
TickTock 124:0d622967b764 474 msgReq.attach(&sendReq,0.015);
TickTock 13:62e0f7f39ff5 475 }
TickTock 13:62e0f7f39ff5 476
TickTock 36:dbd39c315258 477 void playbackISR() { //Used for autoplayback
TickTock 36:dbd39c315258 478 step=true;
TickTock 36:dbd39c315258 479 }
TickTock 36:dbd39c315258 480
TickTock 13:62e0f7f39ff5 481 void recieve1() {
TickTock 13:62e0f7f39ff5 482 CANMessage msg1;
TickTock 13:62e0f7f39ff5 483 can1.read(msg1);
garygid 69:6bfdfc002036 484
TickTock 132:08748a67280a 485 secsNoEvCanMsg=0; // reset deadman switch
garygid 69:6bfdfc002036 486 if( ZeroSecTick ) { ZeroSecTick = false; logTS(); } // gg - 0-second EV bus
TickTock 106:f016912a03db 487 if(msg1.id>0) {
TickTock 106:f016912a03db 488 logCan(1, msg1); // EVcan Message Received
TickTock 106:f016912a03db 489 led1 = !led1;
TickTock 106:f016912a03db 490 }
TickTock 13:62e0f7f39ff5 491 }
TickTock 13:62e0f7f39ff5 492
TickTock 13:62e0f7f39ff5 493 void recieve2() {
TickTock 13:62e0f7f39ff5 494 CANMessage msg2;
TickTock 13:62e0f7f39ff5 495 can2.read(msg2);
garygid 69:6bfdfc002036 496
TickTock 132:08748a67280a 497 secsNoCarCanMsg=0; // reset deadman switch
TickTock 134:ad243e4f1a17 498 if( ZeroSecTick ) { ZeroSecTick = false; logTS(); } // gg - 0-second CAR bus
TickTock 106:f016912a03db 499 if(msg2.id>0) {
TickTock 106:f016912a03db 500 logCan(2, msg2); // CARcan Message Received
TickTock 106:f016912a03db 501 led2 = !led2;
TickTock 106:f016912a03db 502 }
TickTock 13:62e0f7f39ff5 503 }
TickTock 13:62e0f7f39ff5 504
TickTock 22:a43df3905863 505 unsigned char buttonX(unsigned short X, unsigned char columns) {
TickTock 22:a43df3905863 506 unsigned char val = X*columns/320;
TickTock 22:a43df3905863 507 return val;
TickTock 22:a43df3905863 508 }
TickTock 22:a43df3905863 509
TickTock 22:a43df3905863 510 unsigned char buttonY(unsigned short Y, unsigned char rows) {
TickTock 22:a43df3905863 511 unsigned short val = Y*rows/240;
TickTock 22:a43df3905863 512 return val;
TickTock 22:a43df3905863 513 }
TickTock 23:cd03f9c3395e 514
TickTock 23:cd03f9c3395e 515 void saveConfig(){
TickTock 23:cd03f9c3395e 516 FILE *cfile;
TickTock 147:e0f1c84c62a6 517 FIL efile; // external usb file
TickTock 147:e0f1c84c62a6 518 FRESULT sfr; // external file access flags
TickTock 147:e0f1c84c62a6 519 unsigned int bytesRW;
TickTock 147:e0f1c84c62a6 520 const int bufSize = 2048;
TickTock 147:e0f1c84c62a6 521 char buffer[bufSize];
TickTock 150:ef46ce63345c 522 char sTemp[16];
TickTock 174:cd27e80f197d 523
TickTock 174:cd27e80f197d 524 tt.set_font((unsigned char*) Arial12x12);
TickTock 174:cd27e80f197d 525 tt.background(Blue);
TickTock 174:cd27e80f197d 526 tt.foreground(Yellow);
TickTock 174:cd27e80f197d 527 tt.locate(0,10);
TickTock 174:cd27e80f197d 528 tt.cls();
TickTock 174:cd27e80f197d 529
TickTock 150:ef46ce63345c 530 printMsg("Saving local config file.\n");
TickTock 174:cd27e80f197d 531 printf("Saving local config file.\n");
TickTock 99:c05abf8e1cdc 532 cfile = fopen("/local/config.txt", "w");
TickTock 174:cd27e80f197d 533 fprintf(cfile,"format 11\r\n");
TickTock 23:cd03f9c3395e 534 fprintf(cfile,"x0_off %d\r\n",tt.x0_off);
TickTock 23:cd03f9c3395e 535 fprintf(cfile,"y0_off %d\r\n",tt.y0_off);
TickTock 23:cd03f9c3395e 536 fprintf(cfile,"x0_pp %d\r\n",tt.x0_pp);
TickTock 23:cd03f9c3395e 537 fprintf(cfile,"y0_pp %d\r\n",tt.y0_pp);
TickTock 23:cd03f9c3395e 538 fprintf(cfile,"x1_off %d\r\n",tt.x1_off);
TickTock 23:cd03f9c3395e 539 fprintf(cfile,"y1_off %d\r\n",tt.y1_off);
TickTock 23:cd03f9c3395e 540 fprintf(cfile,"x1_pp %d\r\n",tt.x1_pp);
TickTock 23:cd03f9c3395e 541 fprintf(cfile,"y1_pp %d\r\n",tt.y1_pp);
TickTock 23:cd03f9c3395e 542 fprintf(cfile,"x_mid %d\r\n",tt.x_mid);
TickTock 158:059abeb44ba1 543 if ((dMode[0]==configScreen)||(dMode[0]==config2Screen))
TickTock 147:e0f1c84c62a6 544 fprintf(cfile,"dMode0 %d\r\n",mainScreen);
TickTock 147:e0f1c84c62a6 545 else
TickTock 26:462ccb580472 546 fprintf(cfile,"dMode0 %d\r\n",dMode[0]);
TickTock 158:059abeb44ba1 547 if ((dMode[1]==configScreen)||(dMode[1]==config2Screen))
TickTock 147:e0f1c84c62a6 548 fprintf(cfile,"dMode1 %d\r\n",mainScreen);
TickTock 147:e0f1c84c62a6 549 else
TickTock 26:462ccb580472 550 fprintf(cfile,"dMode1 %d\r\n",dMode[1]);
TickTock 35:5acbd8a64a89 551 fprintf(cfile,"ledHi %4.3f\r\n",ledHi);
TickTock 35:5acbd8a64a89 552 fprintf(cfile,"ledLo %4.3f\r\n",ledLo);
TickTock 35:5acbd8a64a89 553 fprintf(cfile,"pollInt %d\r\n",pollInt);
TickTock 35:5acbd8a64a89 554 fprintf(cfile,"scale12V %4.2f\r\n",scale12V);
TickTock 48:d1ce92104a1f 555 fprintf(cfile,"skin %d\r\n",skin);
TickTock 50:83d5864c64a0 556 fprintf(cfile,"dtePeriod %d\r\n",dtePeriod);
garygid 87:46ac3f2519d6 557 fprintf(cfile,"DebugMode %d\r\n",(debugMode?1:0));
leafman 98:9f8bab96edff 558 fprintf(cfile,"metric %d\r\n",(metric?1:0));
leafman 98:9f8bab96edff 559 fprintf(cfile, "firmware %d\r\n", fwCount );
TickTock 131:0d926c080a65 560 fprintf(cfile,"showHealth %d\r\n",(showHealth?1:0));
TickTock 159:577e9d015693 561 fprintf(cfile,"brakeMon %d\r\n",(heaterMon?4:0)+(brakeMon?2:0)+(regenMon?1:0));
TickTock 174:cd27e80f197d 562 fprintf(cfile,"brkMonRate %2.1f\r\n", (float) brkMonRate/94737 );
TickTock 174:cd27e80f197d 563 fprintf(cfile,"brkMonThr %2.1f\r\n", (float) brkMonThr/1895);
TickTock 149:e9739523109f 564 for(char i=0;i<8;i++){
TickTock 150:ef46ce63345c 565 sprintf(sTemp,"usrMsgId %04x",uMsgId[i]);
TickTock 150:ef46ce63345c 566 fprintf(cfile,"%s\r\n", sTemp );
TickTock 149:e9739523109f 567 }
TickTock 152:a4d66901785d 568 fprintf(cfile,"modelYear %d\r\n",modelYear);
TickTock 152:a4d66901785d 569 fprintf(cfile,"autoSync %d\r\n",(autoSync?1:0));
TickTock 170:7ee98e3611bc 570 fprintf(cfile,"kWperGid %4.3f\r\n",kWperGid);
TickTock 23:cd03f9c3395e 571 fclose(cfile);
TickTock 147:e0f1c84c62a6 572
TickTock 147:e0f1c84c62a6 573 // Make copy of CONFIG.TXT
TickTock 150:ef46ce63345c 574 printMsg("Saving CONFIG.BAK.\n");
TickTock 147:e0f1c84c62a6 575 cfile = fopen("/local/CONFIG.TXT", "r");
TickTock 147:e0f1c84c62a6 576 sfr = f_open(&efile,"CONFIG.BAK",FA_WRITE|FA_CREATE_NEW);
TickTock 147:e0f1c84c62a6 577 if((cfile != NULL)&&(sfr == FR_OK)){
TickTock 174:cd27e80f197d 578 printf("Copy config file to USB\n");
TickTock 147:e0f1c84c62a6 579 while (!feof(cfile))
TickTock 147:e0f1c84c62a6 580 {
TickTock 147:e0f1c84c62a6 581 bytesRW=fread(buffer, 1, bufSize, cfile);
TickTock 147:e0f1c84c62a6 582 sfr=f_write(&efile,&buffer,bytesRW,&bytesRW);
TickTock 147:e0f1c84c62a6 583 }
TickTock 147:e0f1c84c62a6 584 fflush(cfile);
TickTock 147:e0f1c84c62a6 585 fclose(cfile);
TickTock 147:e0f1c84c62a6 586 f_close(&efile);
TickTock 147:e0f1c84c62a6 587 }
TickTock 150:ef46ce63345c 588
TickTock 150:ef46ce63345c 589 // Make copy of ehist.cny
TickTock 150:ef46ce63345c 590 printMsg("Saving ehist.bak.\n");
TickTock 150:ef46ce63345c 591 cfile = fopen("/local/ehist.cny", "r");
TickTock 150:ef46ce63345c 592 sfr = f_open(&efile,"ehist.bak",FA_WRITE|FA_CREATE_NEW);
TickTock 150:ef46ce63345c 593 if((cfile != NULL)&&(sfr == FR_OK)){
TickTock 174:cd27e80f197d 594 printf("Copy ehist file to USB\n");
TickTock 150:ef46ce63345c 595 while (!feof(cfile))
TickTock 150:ef46ce63345c 596 {
TickTock 150:ef46ce63345c 597 bytesRW=fread(buffer, 1, bufSize, cfile);
TickTock 150:ef46ce63345c 598 sfr=f_write(&efile,&buffer,bytesRW,&bytesRW);
TickTock 150:ef46ce63345c 599 }
TickTock 150:ef46ce63345c 600 fflush(cfile);
TickTock 150:ef46ce63345c 601 fclose(cfile);
TickTock 150:ef46ce63345c 602 f_close(&efile);
TickTock 150:ef46ce63345c 603 }
TickTock 174:cd27e80f197d 604 wait(3);
TickTock 23:cd03f9c3395e 605 }
TickTock 23:cd03f9c3395e 606
TickTock 111:d1559bb25c43 607 void readConfig(){
TickTock 23:cd03f9c3395e 608 FILE *cfile;
TickTock 152:a4d66901785d 609 int ff,readHex,readBool;
TickTock 150:ef46ce63345c 610 char sTemp[16];
TickTock 174:cd27e80f197d 611 float readFloat;
TickTock 131:0d926c080a65 612
TickTock 23:cd03f9c3395e 613 cfile = fopen("/local/config.txt", "r");
TickTock 23:cd03f9c3395e 614 if (cfile==NULL){ // if doesn't exist --> create
TickTock 116:5cd72bae7c12 615 printMsg("No config file found.\n"); // no config file
TickTock 116:5cd72bae7c12 616 printMsg("Calibrating touch screen.\n"); // calibrating
TickTock 23:cd03f9c3395e 617 //tt.setcal(5570, 34030, 80, 108, 33700, 5780, 82, 108, 32500);// bypass calibration using my values
TickTock 23:cd03f9c3395e 618 tt.calibrate(); // run touchscreen calibration routine
garygid 58:4d06288d75a2 619 // NOTE: calibrates screen 1 first, then screen 0.
TickTock 23:cd03f9c3395e 620 saveConfig();
TickTock 23:cd03f9c3395e 621 } else {
TickTock 102:fd19f777a0b4 622 ledHi = 0.8;
TickTock 150:ef46ce63345c 623 ledLo = 0.3;
TickTock 102:fd19f777a0b4 624 pollInt = 60;
TickTock 48:d1ce92104a1f 625 scale12V = 16.2;
TickTock 170:7ee98e3611bc 626 kWperGid=0.080;
TickTock 48:d1ce92104a1f 627 skin = ttSkin;
leafman 98:9f8bab96edff 628 fscanf(cfile, "format %d\r\n", &ff );
leafman 98:9f8bab96edff 629 fscanf(cfile, "x0_off %d\r\n", &tt.x0_off );
leafman 98:9f8bab96edff 630 fscanf(cfile, "y0_off %d\r\n", &tt.y0_off );
leafman 98:9f8bab96edff 631 fscanf(cfile, "x0_pp %d\r\n", &tt.x0_pp );
leafman 98:9f8bab96edff 632 fscanf(cfile, "y0_pp %d\r\n", &tt.y0_pp );
leafman 98:9f8bab96edff 633 fscanf(cfile, "x1_off %d\r\n", &tt.x1_off );
leafman 98:9f8bab96edff 634 fscanf(cfile, "y1_off %d\r\n", &tt.y1_off );
leafman 98:9f8bab96edff 635 fscanf(cfile, "x1_pp %d\r\n", &tt.x1_pp );
leafman 98:9f8bab96edff 636 fscanf(cfile, "y1_pp %d\r\n", &tt.y1_pp );
leafman 98:9f8bab96edff 637 fscanf(cfile, "x_mid %d\r\n", &tt.x_mid );
leafman 98:9f8bab96edff 638 fscanf(cfile, "dMode0 %d\r\n", &dMode[0] );
leafman 98:9f8bab96edff 639 fscanf(cfile, "dMode1 %d\r\n", &dMode[1] );
TickTock 35:5acbd8a64a89 640 if(ff>1){
leafman 98:9f8bab96edff 641 fscanf(cfile, "ledHi %f\r\n", &ledHi );
leafman 98:9f8bab96edff 642 fscanf(cfile, "ledLo %f\r\n", &ledLo );
leafman 98:9f8bab96edff 643 fscanf(cfile, "pollInt %d\r\n", &pollInt );
leafman 98:9f8bab96edff 644 fscanf(cfile, "scale12V %f\r\n", &scale12V );
TickTock 48:d1ce92104a1f 645 }
TickTock 48:d1ce92104a1f 646 if(ff>2){
leafman 98:9f8bab96edff 647 fscanf(cfile, "skin %d\r\n", &skin );
leafman 98:9f8bab96edff 648 fscanf(cfile, "dtePeriod %d\r\n", &dtePeriod );
TickTock 35:5acbd8a64a89 649 }
garygid 87:46ac3f2519d6 650 if(ff>3){
TickTock 152:a4d66901785d 651 fscanf(cfile, "DebugMode %d\r\n", &readBool );
TickTock 152:a4d66901785d 652 debugMode = (bool)readBool;
leafman 98:9f8bab96edff 653 }
leafman 98:9f8bab96edff 654 if(ff>4) {
TickTock 152:a4d66901785d 655 fscanf(cfile, "metric %d\r\n", &readBool );
TickTock 152:a4d66901785d 656 metric = (bool)readBool; // This will get re-assigned based on dash selection
TickTock 152:a4d66901785d 657 fscanf(cfile, "firmware %d\r\n", &fwCount );
TickTock 35:5acbd8a64a89 658 }
TickTock 131:0d926c080a65 659 if(ff>5){
TickTock 152:a4d66901785d 660 fscanf(cfile, "showHealth %d\r\n", &readBool );
TickTock 152:a4d66901785d 661 showHealth = (bool)readBool;
TickTock 131:0d926c080a65 662 }
TickTock 140:ab3e94eb0227 663 if(ff>6){
TickTock 155:f31006516956 664 fscanf(cfile, "brakeMon %d\r\n", &readBool );
TickTock 155:f31006516956 665 brakeMon = (bool)(readBool&1);
TickTock 155:f31006516956 666 regenMon = (bool)(readBool&2);
TickTock 159:577e9d015693 667 heaterMon = (bool)(readBool&4);
TickTock 174:cd27e80f197d 668 if(ff>10){
TickTock 174:cd27e80f197d 669 fscanf(cfile, "brkMonRate %f\r\n", &readFloat );
TickTock 174:cd27e80f197d 670 brkMonRate = 94737 * readFloat;
TickTock 174:cd27e80f197d 671 fscanf(cfile, "brkMonThr %f\r\n", &readFloat );
TickTock 174:cd27e80f197d 672 brkMonThr = 1895 * readFloat;
TickTock 174:cd27e80f197d 673 }else{
TickTock 174:cd27e80f197d 674 fscanf(cfile, "brkMonRate %d\r\n", &brkMonRate );
TickTock 174:cd27e80f197d 675 fscanf(cfile, "brkMonThr %d\r\n", &brkMonThr);
TickTock 174:cd27e80f197d 676 brkMonRate = 378948;
TickTock 174:cd27e80f197d 677 brkMonThr = 1895;
TickTock 174:cd27e80f197d 678 }
TickTock 140:ab3e94eb0227 679 }
TickTock 149:e9739523109f 680 if(ff>7){
TickTock 149:e9739523109f 681 for(char i=0;i<8;i++){
TickTock 150:ef46ce63345c 682 fscanf(cfile, "usrMsgId %s\r\n", &sTemp );
TickTock 152:a4d66901785d 683 sscanf(sTemp,"%x", &readHex);
TickTock 152:a4d66901785d 684 uMsgId[i]=readHex;
TickTock 149:e9739523109f 685 }
TickTock 149:e9739523109f 686 }
TickTock 152:a4d66901785d 687 if(ff>8){
TickTock 152:a4d66901785d 688 fscanf(cfile, "modelYear %d\r\n", &modelYear);
TickTock 158:059abeb44ba1 689 fscanf(cfile, "autoSync %d\r\n", &readBool);
TickTock 152:a4d66901785d 690 autoSync = (bool)readBool;
TickTock 152:a4d66901785d 691 }
TickTock 170:7ee98e3611bc 692 if(ff>9){
TickTock 170:7ee98e3611bc 693 fscanf(cfile, "kWperGid %f\r\n", &kWperGid );
TickTock 170:7ee98e3611bc 694 }
TickTock 23:cd03f9c3395e 695 fclose(cfile);
TickTock 174:cd27e80f197d 696 if((ff>11)||(ff<1)||(ledHi<0.1)||(scale12V<10)||(tt.x_mid<16000)||(ledHi>1)||(ledLo>1)||(dMode[0]>maxScreens)||(dMode[1]>maxScreens)){ //Sanity check a few things
TickTock 148:6e3b9135fad2 697 //Something wrong. Load defaults
TickTock 174:cd27e80f197d 698 printMsg("Invalid config file. Loading defaults.\n");
TickTock 148:6e3b9135fad2 699 wait(3);
TickTock 174:cd27e80f197d 700 ff=11;
TickTock 148:6e3b9135fad2 701 tt.x0_off=5732;
TickTock 148:6e3b9135fad2 702 tt.y0_off=34009;
TickTock 148:6e3b9135fad2 703 tt.x0_pp=77;
TickTock 148:6e3b9135fad2 704 tt.y0_pp=106;
TickTock 148:6e3b9135fad2 705 tt.x1_off=33955;
TickTock 148:6e3b9135fad2 706 tt.y1_off=6310;
TickTock 148:6e3b9135fad2 707 tt.x1_pp=80;
TickTock 148:6e3b9135fad2 708 tt.y1_pp=104;
TickTock 148:6e3b9135fad2 709 tt.x_mid=31986;
TickTock 152:a4d66901785d 710 dMode[0]=2;
TickTock 152:a4d66901785d 711 dMode[1]=4;
TickTock 148:6e3b9135fad2 712 ledHi=0.800;
TickTock 150:ef46ce63345c 713 ledLo=0.300;
TickTock 148:6e3b9135fad2 714 pollInt=300;
TickTock 148:6e3b9135fad2 715 scale12V=16.20;
TickTock 148:6e3b9135fad2 716 skin=0;
TickTock 148:6e3b9135fad2 717 dtePeriod=14;
TickTock 148:6e3b9135fad2 718 debugMode=false;
TickTock 148:6e3b9135fad2 719 metric=false;
TickTock 148:6e3b9135fad2 720 fwCount=1;
TickTock 148:6e3b9135fad2 721 showHealth=true;
TickTock 148:6e3b9135fad2 722 brakeMon=true;
TickTock 155:f31006516956 723 regenMon=true;
TickTock 159:577e9d015693 724 heaterMon=true;
TickTock 174:cd27e80f197d 725 brkMonRate=378947; // 4Wh per chirp
TickTock 174:cd27e80f197d 726 brkMonThr=1895; // 1Wh per second
TickTock 149:e9739523109f 727 uMsgId[0]=0x5103;
TickTock 149:e9739523109f 728 uMsgId[1]=0x50a3;
TickTock 149:e9739523109f 729 uMsgId[2]=0x54a4;
TickTock 149:e9739523109f 730 uMsgId[3]=0x54b4;
TickTock 149:e9739523109f 731 uMsgId[4]=0x54c0;
TickTock 149:e9739523109f 732 uMsgId[5]=0x55b4;
TickTock 149:e9739523109f 733 uMsgId[6]=0x0000;
TickTock 149:e9739523109f 734 uMsgId[7]=0x0000;
TickTock 152:a4d66901785d 735 modelYear=2011;
TickTock 152:a4d66901785d 736 autoSync=false;
TickTock 170:7ee98e3611bc 737 kWperGid=0.080;
TickTock 148:6e3b9135fad2 738 }
TickTock 174:cd27e80f197d 739 if(ff<11){//If not latest format, save as latest format
TickTock 35:5acbd8a64a89 740 saveConfig();
TickTock 174:cd27e80f197d 741 printMsg("Config file format updated.\n"); // config format updates
TickTock 48:d1ce92104a1f 742 }
TickTock 116:5cd72bae7c12 743 printMsg("Config file loaded.\n"); // config file loaded
TickTock 23:cd03f9c3395e 744 }
TickTock 23:cd03f9c3395e 745 }
TickTock 25:ddf0ec209f03 746
TickTock 25:ddf0ec209f03 747 void upDate(unsigned char field, bool upDownBar){
TickTock 25:ddf0ec209f03 748 struct tm t; // pointer to a static tm structure
TickTock 25:ddf0ec209f03 749 time_t seconds ;
TickTock 25:ddf0ec209f03 750 seconds = time(NULL);
TickTock 25:ddf0ec209f03 751 t = *localtime(&seconds) ;
TickTock 25:ddf0ec209f03 752 switch(field){
TickTock 25:ddf0ec209f03 753 case 0: // year
TickTock 25:ddf0ec209f03 754 if (upDownBar) {
TickTock 25:ddf0ec209f03 755 t.tm_year = t.tm_year+1;
TickTock 25:ddf0ec209f03 756 } else {
TickTock 25:ddf0ec209f03 757 t.tm_year = t.tm_year-1;
TickTock 25:ddf0ec209f03 758 }
TickTock 25:ddf0ec209f03 759 break;
TickTock 25:ddf0ec209f03 760 case 1: // month
TickTock 25:ddf0ec209f03 761 if (upDownBar) {
TickTock 152:a4d66901785d 762 t.tm_mon = (t.tm_mon<11)?t.tm_mon+1:0;
TickTock 25:ddf0ec209f03 763 } else {
TickTock 152:a4d66901785d 764 t.tm_mon = (t.tm_mon>0)?t.tm_mon-1:11;
TickTock 25:ddf0ec209f03 765 }
TickTock 25:ddf0ec209f03 766 break;
TickTock 25:ddf0ec209f03 767 case 2: // day
TickTock 25:ddf0ec209f03 768 if (upDownBar) {
TickTock 25:ddf0ec209f03 769 t.tm_mday = (t.tm_mday<31)?t.tm_mday+1:1;
TickTock 25:ddf0ec209f03 770 } else {
TickTock 152:a4d66901785d 771 t.tm_mday = (t.tm_mday>1)?t.tm_mday-1:31;
TickTock 25:ddf0ec209f03 772 }
TickTock 25:ddf0ec209f03 773 break;
TickTock 25:ddf0ec209f03 774 case 3: // hour
TickTock 25:ddf0ec209f03 775 if (upDownBar) {
TickTock 25:ddf0ec209f03 776 t.tm_hour = (t.tm_hour<23)?t.tm_hour+1:0;
TickTock 25:ddf0ec209f03 777 } else {
TickTock 152:a4d66901785d 778 t.tm_hour = (t.tm_hour>0)?t.tm_hour-1:23;
TickTock 25:ddf0ec209f03 779 }
TickTock 25:ddf0ec209f03 780 break;
TickTock 25:ddf0ec209f03 781 case 4: // minute
TickTock 25:ddf0ec209f03 782 if (upDownBar) {
TickTock 25:ddf0ec209f03 783 t.tm_min = (t.tm_min<59)?t.tm_min+1:0;
TickTock 25:ddf0ec209f03 784 } else {
TickTock 152:a4d66901785d 785 t.tm_min = (t.tm_min>0)?t.tm_min-1:59;
TickTock 25:ddf0ec209f03 786 }
TickTock 25:ddf0ec209f03 787 break;
TickTock 25:ddf0ec209f03 788 case 5: // second
TickTock 25:ddf0ec209f03 789 if (upDownBar) {
TickTock 25:ddf0ec209f03 790 t.tm_sec = (t.tm_sec<59)?t.tm_sec+1:0;
TickTock 25:ddf0ec209f03 791 } else {
TickTock 152:a4d66901785d 792 t.tm_sec = (t.tm_sec>0)?t.tm_sec-1:59;
TickTock 25:ddf0ec209f03 793 }
TickTock 25:ddf0ec209f03 794 break;
TickTock 25:ddf0ec209f03 795 default:
TickTock 25:ddf0ec209f03 796 break;
TickTock 25:ddf0ec209f03 797 }
TickTock 25:ddf0ec209f03 798 set_time(mktime(&t));
TickTock 25:ddf0ec209f03 799 }
TickTock 25:ddf0ec209f03 800
TickTock 153:e94cfe3c339c 801 bool syncDateTime(){ // doesn't work on MY2013
TickTock 152:a4d66901785d 802 struct tm t; // pointer to a static tm structure
TickTock 152:a4d66901785d 803 time_t seconds ;
TickTock 152:a4d66901785d 804 CANMessage msg;
TickTock 160:905fe45ed54b 805 static unsigned char lastHour, numMatched;
TickTock 152:a4d66901785d 806 seconds = time(NULL);
TickTock 152:a4d66901785d 807 t = *localtime(&seconds);
TickTock 153:e94cfe3c339c 808 if(modelYear<2013){ //MY2011,2012
TickTock 153:e94cfe3c339c 809 msg = lastMsg[indexLastMsg[0x5fa]];
TickTock 153:e94cfe3c339c 810 t.tm_mon = (msg.data[5]>>4)-1;
TickTock 153:e94cfe3c339c 811 t.tm_mday = msg.data[2]>>3;
TickTock 153:e94cfe3c339c 812 msg = lastMsg[indexLastMsg[0x5fb]];
TickTock 153:e94cfe3c339c 813 //t.tm_year = msg.data[1]; // Have not figured out where the year is
TickTock 153:e94cfe3c339c 814 msg = lastMsg[indexLastMsg[0x5fc]];
TickTock 153:e94cfe3c339c 815 t.tm_hour = msg.data[0]>>3;
TickTock 153:e94cfe3c339c 816 t.tm_min = (msg.data[1]<<4&0x30)+(msg.data[2]>>4);
TickTock 153:e94cfe3c339c 817 t.tm_sec = msg.data[1]>>2;
TickTock 153:e94cfe3c339c 818 }else{ // model year 2013 or higher
TickTock 153:e94cfe3c339c 819 msg = lastMsg[indexLastMsg[0x5f9]];
TickTock 153:e94cfe3c339c 820 t.tm_hour = msg.data[5]>>3;
TickTock 153:e94cfe3c339c 821 t.tm_min = msg.data[4];
TickTock 153:e94cfe3c339c 822 msg = lastMsg[indexLastMsg[0x509]];
TickTock 153:e94cfe3c339c 823 t.tm_sec = msg.data[2]>>2;
TickTock 153:e94cfe3c339c 824 }
TickTock 160:905fe45ed54b 825 if(t.tm_hour==lastHour){ //filter
TickTock 160:905fe45ed54b 826 numMatched++;
TickTock 160:905fe45ed54b 827 }else{
TickTock 160:905fe45ed54b 828 numMatched=0;
TickTock 160:905fe45ed54b 829 }
TickTock 160:905fe45ed54b 830 lastHour=t.tm_hour;
TickTock 160:905fe45ed54b 831 if((numMatched>5)&&(t.tm_mon>=0)&&(t.tm_mon<12)&&(t.tm_mday>0)&&(t.tm_mday<32)&&(t.tm_hour>=0)&&(t.tm_hour<24)&&(t.tm_min>=0)&&(t.tm_min<60)&&(t.tm_sec>=0)&&(t.tm_sec<60)){ // sanity check result before using
TickTock 153:e94cfe3c339c 832 set_time(mktime(&t));
TickTock 160:905fe45ed54b 833 numMatched=0;
TickTock 153:e94cfe3c339c 834 return(true);
TickTock 153:e94cfe3c339c 835 }else{
TickTock 153:e94cfe3c339c 836 return(false);
TickTock 153:e94cfe3c339c 837 }
TickTock 153:e94cfe3c339c 838
TickTock 152:a4d66901785d 839 }
TickTock 152:a4d66901785d 840
TickTock 39:eef8beac7411 841 void logPackVoltages() { // Turbo3 - routine to dump CP values to text file
TickTock 39:eef8beac7411 842 char sTemp[40];
TickTock 39:eef8beac7411 843 struct tm t; // pointer to a static tm structure
TickTock 39:eef8beac7411 844 short unsigned max, min, jv, i, bd;
TickTock 39:eef8beac7411 845 unsigned avg;
TickTock 119:0e2b641e98a2 846 unsigned short gids, SOC, packV_x2;
TickTock 140:ab3e94eb0227 847 unsigned long odo;
TickTock 119:0e2b641e98a2 848 signed short packA_x2;
TickTock 39:eef8beac7411 849 time_t seconds ;
TickTock 39:eef8beac7411 850
TickTock 39:eef8beac7411 851 CANMessage msg;
TickTock 39:eef8beac7411 852
TickTock 39:eef8beac7411 853 seconds = time(NULL); // Turbo3
TickTock 39:eef8beac7411 854 t = *localtime(&seconds) ; // Turbo3
TickTock 39:eef8beac7411 855
TickTock 39:eef8beac7411 856 msg = lastMsg[indexLastMsg[0x5bc]]; //Get gids
TickTock 39:eef8beac7411 857 gids = (msg.data[0]<<2)+(msg.data[1]>>6);
TickTock 140:ab3e94eb0227 858 msg = lastMsg[indexLastMsg[0x5c5]]; //Get odometer
TickTock 140:ab3e94eb0227 859 odo = (msg.data[1]<16)+(msg.data[2]<<8)+msg.data[3];
TickTock 39:eef8beac7411 860 msg = lastMsg[indexLastMsg[0x55b]]; //Get SOC
TickTock 39:eef8beac7411 861 SOC = (msg.data[0]<<2)+(msg.data[1]>>6);
TickTock 39:eef8beac7411 862 msg = lastMsg[indexLastMsg[0x1db]]; //Get pack volts
TickTock 119:0e2b641e98a2 863 packV_x2 = (msg.data[2]<<2)+(msg.data[3]>>6);
TickTock 119:0e2b641e98a2 864 packA_x2 = (msg.data[0]<<3)+(msg.data[1]>>5);
TickTock 119:0e2b641e98a2 865 if (packA_x2 & 0x400) packA_x2 |= 0xf800;
TickTock 39:eef8beac7411 866
TickTock 39:eef8beac7411 867 max=0;
TickTock 39:eef8beac7411 868 min=9999;
TickTock 39:eef8beac7411 869 avg=0;
TickTock 92:935adef49ea4 870 for(i=0; i<96; i++) {
TickTock 124:0d622967b764 871 bd=(battData[BatDataBaseG2*7+i*2+3]<<8)+battData[BatDataBaseG2*7+i*2+4];
TickTock 39:eef8beac7411 872 avg+=bd;
TickTock 39:eef8beac7411 873 if(bd>max) max=bd;
TickTock 39:eef8beac7411 874 if(bd<min) min=bd;
TickTock 39:eef8beac7411 875 }
TickTock 39:eef8beac7411 876 avg /= 96;
TickTock 39:eef8beac7411 877 if(min<3713) {
TickTock 39:eef8beac7411 878 jv=avg-(max-avg)*1.5;
TickTock 39:eef8beac7411 879 } else { // Only compute judgement value if min cellpair meets <= 3712mV requirement
TickTock 39:eef8beac7411 880 jv=0;
TickTock 39:eef8beac7411 881 }
TickTock 39:eef8beac7411 882
TickTock 110:ffddff3ad2f2 883 FIL bfile;
TickTock 110:ffddff3ad2f2 884 FRESULT bfr;
TickTock 110:ffddff3ad2f2 885 bfr = f_open(&bfile,"batvolt.txt",FA_WRITE|FA_OPEN_ALWAYS);
TickTock 110:ffddff3ad2f2 886 if(bfr==FR_OK) {
TickTock 110:ffddff3ad2f2 887 f_lseek(&bfile,0xffffffff); // go to end of file to append
TickTock 39:eef8beac7411 888 strftime(sTemp, 40, "%a %m/%d/%Y %X", &t);
TickTock 110:ffddff3ad2f2 889 f_printf(&bfile,"%s,",sTemp);
TickTock 140:ab3e94eb0227 890 sprintf(sTemp,"%d,%d,%5.1f%%,%5.1f,%5.1f,%d,%d,%d,%d,%d",odo,gids,(float)SOC/10,(float)packV_x2/2,(float)packA_x2/2,max,min,avg,max-min,jv);
TickTock 110:ffddff3ad2f2 891 f_printf(&bfile,"%s,",sTemp);
TickTock 124:0d622967b764 892 f_printf(&bfile,"%d,%d,%d,%d,",(battData[(BatDataBaseG4*7)+ 3]<<8)+battData[(BatDataBaseG4*7)+ 4],battData[(BatDataBaseG4*7)+ 5],(battData[(BatDataBaseG4*7)+ 6]<<8)+battData[(BatDataBaseG4*7)+ 7],battData[(BatDataBaseG4*7)+ 8]);
TickTock 124:0d622967b764 893 f_printf(&bfile,"%d,%d,%d,%d", (battData[(BatDataBaseG4*7)+ 9]<<8)+battData[(BatDataBaseG4*7)+10],battData[(BatDataBaseG4*7)+11],(battData[(BatDataBaseG4*7)+12]<<8)+battData[(BatDataBaseG4*7)+13],battData[(BatDataBaseG4*7)+14]);
TickTock 108:29b5a760adc2 894 for(i=0; i<96; i++) {
TickTock 124:0d622967b764 895 bd=(battData[BatDataBaseG2*7+i*2+3]<<8)+battData[BatDataBaseG2*7+i*2+4];
TickTock 110:ffddff3ad2f2 896 f_printf(&bfile,",%d",bd);
TickTock 108:29b5a760adc2 897 }
TickTock 110:ffddff3ad2f2 898 f_printf(&bfile,"\r\n");
TickTock 110:ffddff3ad2f2 899 f_close(&bfile);
TickTock 110:ffddff3ad2f2 900 }
TickTock 108:29b5a760adc2 901 logCP=false;
TickTock 108:29b5a760adc2 902 showCP=true;
TickTock 108:29b5a760adc2 903 }
TickTock 108:29b5a760adc2 904
TickTock 108:29b5a760adc2 905 void tripLog() { // Daily log
TickTock 110:ffddff3ad2f2 906 char sTemp[40];
TickTock 155:f31006516956 907 unsigned char ambient;
TickTock 108:29b5a760adc2 908 struct tm t; // pointer to a static tm structure
TickTock 108:29b5a760adc2 909 short unsigned max, min, jv, i, bd;
TickTock 108:29b5a760adc2 910 unsigned avg;
TickTock 119:0e2b641e98a2 911 unsigned short gids, SOC, packV_x2;
TickTock 140:ab3e94eb0227 912 unsigned long odo;
TickTock 119:0e2b641e98a2 913 signed short packA_x2;
TickTock 39:eef8beac7411 914 time_t seconds ;
TickTock 39:eef8beac7411 915
TickTock 39:eef8beac7411 916 CANMessage msg;
TickTock 39:eef8beac7411 917
TickTock 39:eef8beac7411 918 seconds = time(NULL); // Turbo3
TickTock 39:eef8beac7411 919 t = *localtime(&seconds) ; // Turbo3
TickTock 39:eef8beac7411 920
TickTock 155:f31006516956 921 msg = lastMsg[indexLastMsg[0x54c]]; //Get ambient
TickTock 155:f31006516956 922 ambient = msg.data[6]-56;
TickTock 39:eef8beac7411 923 msg = lastMsg[indexLastMsg[0x5bc]]; //Get gids
TickTock 39:eef8beac7411 924 gids = (msg.data[0]<<2)+(msg.data[1]>>6);
TickTock 140:ab3e94eb0227 925 msg = lastMsg[indexLastMsg[0x5c5]]; //Get odometer
TickTock 140:ab3e94eb0227 926 odo = (msg.data[1]<16)+(msg.data[2]<<8)+msg.data[3];
TickTock 39:eef8beac7411 927 msg = lastMsg[indexLastMsg[0x55b]]; //Get SOC
TickTock 39:eef8beac7411 928 SOC = (msg.data[0]<<2)+(msg.data[1]>>6);
TickTock 39:eef8beac7411 929 msg = lastMsg[indexLastMsg[0x1db]]; //Get pack volts
TickTock 119:0e2b641e98a2 930 packV_x2 = (msg.data[2]<<2)+(msg.data[3]>>6);
TickTock 119:0e2b641e98a2 931 packA_x2 = (msg.data[0]<<3)+(msg.data[1]>>5);
TickTock 119:0e2b641e98a2 932 if (packA_x2 & 0x400) packA_x2 |= 0xf800;
TickTock 39:eef8beac7411 933
TickTock 39:eef8beac7411 934 max=0;
TickTock 39:eef8beac7411 935 min=9999;
TickTock 39:eef8beac7411 936 avg=0;
TickTock 39:eef8beac7411 937 for(i=0; i<96; i++) {
TickTock 124:0d622967b764 938 bd=(battData[BatDataBaseG2*7+i*2+3]<<8)+battData[BatDataBaseG2*7+i*2+4];
TickTock 39:eef8beac7411 939 avg+=bd;
TickTock 39:eef8beac7411 940 if(bd>max) max=bd;
TickTock 39:eef8beac7411 941 if(bd<min) min=bd;
TickTock 39:eef8beac7411 942 }
TickTock 39:eef8beac7411 943 avg /= 96;
TickTock 39:eef8beac7411 944 if(min<3713) {
TickTock 39:eef8beac7411 945 jv=avg-(max-avg)*1.5;
TickTock 39:eef8beac7411 946 } else { // Only compute judgement value if min cellpair meets <= 3712mV requirement
TickTock 39:eef8beac7411 947 jv=0;
TickTock 39:eef8beac7411 948 }
TickTock 39:eef8beac7411 949
TickTock 110:ffddff3ad2f2 950 FIL bfile;
TickTock 110:ffddff3ad2f2 951 FRESULT bfr;
TickTock 111:d1559bb25c43 952 bfr = f_open(&bfile,"triplog.txt",FA_WRITE|FA_OPEN_ALWAYS);
TickTock 110:ffddff3ad2f2 953 if(bfr==FR_OK) {
TickTock 110:ffddff3ad2f2 954 f_lseek(&bfile,0xffffffff); // go to end of file to append
TickTock 170:7ee98e3611bc 955 // timestamp, odometer, accV, gids, SOC, SOH2, Ah, Vbatt, Ibatt, Rest, maxCP, minCP, avgCO, maxCP-minCP, CVLI_jv, miles_trip, kWh_trip, CCkWh_trip, ambient, T1raw, T1, T2raw, T2, T3raw, T3, T4raw, T4, CP1, CP2, ... , CP96
TickTock 39:eef8beac7411 956 strftime(sTemp, 40, "%a %m/%d/%Y %X", &t);
TickTock 110:ffddff3ad2f2 957 f_printf(&bfile,"%s,",sTemp);
TickTock 170:7ee98e3611bc 958 sprintf(sTemp,"%d,%3.1f,%d,%5.1f%%,%5.1f%%,%4.2f,%5.1f,%4.1f,%4.3f,%d,%d,%d,%d,%d,%4.1f,%4.2f,%4.2f",odo,accV,gids,(float)SOC/10, (float)SOH2_x100/100,(float)Ah_x10000/10000,(float)packV_x2/2,(float)packA_x2/2,Resr,max,min,avg,max-min,jv,miles_trip[0],kWh_trip[0],CCkWh_trip[0]);
TickTock 155:f31006516956 959 f_printf(&bfile,"%s,%d,",sTemp,ambient);
TickTock 124:0d622967b764 960 f_printf(&bfile,"%d,%d,%d,%d,",(battData[(BatDataBaseG4*7)+ 3]<<8)+battData[(BatDataBaseG4*7)+ 4],battData[(BatDataBaseG4*7)+ 5],(battData[(BatDataBaseG4*7)+ 6]<<8)+battData[(BatDataBaseG4*7)+ 7],battData[(BatDataBaseG4*7)+ 8]);
TickTock 124:0d622967b764 961 f_printf(&bfile,"%d,%d,%d,%d", (battData[(BatDataBaseG4*7)+ 9]<<8)+battData[(BatDataBaseG4*7)+10],battData[(BatDataBaseG4*7)+11],(battData[(BatDataBaseG4*7)+12]<<8)+battData[(BatDataBaseG4*7)+13],battData[(BatDataBaseG4*7)+14]);
TickTock 142:c1a11d6f181c 962 for(i=0; i<96; i++) {
TickTock 124:0d622967b764 963 bd=(battData[BatDataBaseG2*7+i*2+3]<<8)+battData[BatDataBaseG2*7+i*2+4];
TickTock 110:ffddff3ad2f2 964 f_printf(&bfile,",%d",bd);
TickTock 142:c1a11d6f181c 965 }
TickTock 110:ffddff3ad2f2 966 f_printf(&bfile,"\r\n");
TickTock 110:ffddff3ad2f2 967 f_close(&bfile);
TickTock 39:eef8beac7411 968 }
TickTock 39:eef8beac7411 969 }
TickTock 25:ddf0ec209f03 970
leafman 98:9f8bab96edff 971 //LM - updates firmware off a usb key, eliminating the need to plug
leafman 98:9f8bab96edff 972 //the CANary into a computer for updates.
leafman 98:9f8bab96edff 973 void updateFirmware()
leafman 98:9f8bab96edff 974 {
TickTock 143:88b5155622a5 975 FIL efile; // external usb file
TickTock 111:d1559bb25c43 976 FRESULT sfr; // external file access flags
TickTock 111:d1559bb25c43 977 unsigned int bytesRW;
TickTock 111:d1559bb25c43 978 char sTemp[40];
TickTock 131:0d926c080a65 979 const int bufSize = 2048;
TickTock 131:0d926c080a65 980 char buffer[bufSize];
TickTock 143:88b5155622a5 981 FILE *lfile;
TickTock 131:0d926c080a65 982
TickTock 158:059abeb44ba1 983 tt.set_font((unsigned char*) Arial12x12);
TickTock 151:3047ebb3c9a8 984 tt.background(Blue);
TickTock 151:3047ebb3c9a8 985 tt.foreground(Yellow);
TickTock 151:3047ebb3c9a8 986 tt.locate(0,10);
TickTock 151:3047ebb3c9a8 987 tt.cls();
TickTock 150:ef46ce63345c 988
TickTock 143:88b5155622a5 989 sfr = f_open(&efile,"firmware.bin",FA_READ|FA_OPEN_EXISTING);
TickTock 111:d1559bb25c43 990 if(sfr != FR_OK)
TickTock 99:c05abf8e1cdc 991 {
TickTock 137:70853cf5a30f 992 printf("Couldn't find firmware.bin\n");
TickTock 108:29b5a760adc2 993 wait(3);
TickTock 100:63a7456fc972 994 lastDMode[whichTouched]=99;//force refresh
TickTock 99:c05abf8e1cdc 995 return;
TickTock 99:c05abf8e1cdc 996 }
leafman 98:9f8bab96edff 997 fwCount ++;
TickTock 151:3047ebb3c9a8 998 printf("Saving config.\n");
TickTock 148:6e3b9135fad2 999 saveConfig();
leafman 98:9f8bab96edff 1000 //delete all bin files in /local
leafman 98:9f8bab96edff 1001 DIR *dir;
leafman 98:9f8bab96edff 1002 struct dirent *ent;
TickTock 151:3047ebb3c9a8 1003 printf("Starting update.\n");
TickTock 151:3047ebb3c9a8 1004 printf("Deleting old firmware files.\n");
leafman 98:9f8bab96edff 1005 if ((dir = opendir ("/local/")) != NULL) {
TickTock 109:3e6f0e8fca0d 1006 // print all the files and directories within directory
leafman 98:9f8bab96edff 1007 while ((ent = readdir (dir)) != NULL) {
leafman 98:9f8bab96edff 1008 //printf("FILE: %s\n",ent->d_name);
leafman 98:9f8bab96edff 1009 char dest[4] = "";
leafman 98:9f8bab96edff 1010 strncat(dest, &ent->d_name[strlen(ent->d_name)-3],3);
leafman 98:9f8bab96edff 1011 dest[0] = tolower(dest[0]);
leafman 98:9f8bab96edff 1012 dest[1] = tolower(dest[1]);
leafman 98:9f8bab96edff 1013 dest[2] = tolower(dest[2]);
leafman 98:9f8bab96edff 1014 if(strcmp(dest,"bin")==0)
leafman 98:9f8bab96edff 1015 {
leafman 98:9f8bab96edff 1016 sprintf(sTemp,"/local/%s",ent->d_name);
leafman 98:9f8bab96edff 1017 int result = remove(sTemp);
TickTock 151:3047ebb3c9a8 1018 printf("deleted: %s\n",ent->d_name);
leafman 98:9f8bab96edff 1019 }
leafman 98:9f8bab96edff 1020 }
leafman 98:9f8bab96edff 1021 closedir (dir);
leafman 98:9f8bab96edff 1022 } else {
TickTock 109:3e6f0e8fca0d 1023 //could not open directory
TickTock 151:3047ebb3c9a8 1024 printf("Couldn't open folder.\n");
TickTock 160:905fe45ed54b 1025 wait(3);
leafman 98:9f8bab96edff 1026 return;
leafman 98:9f8bab96edff 1027 }
TickTock 151:3047ebb3c9a8 1028 printf("Copying new firmware.\n");
leafman 98:9f8bab96edff 1029 //Copy the new firmware from usb->local
TickTock 131:0d926c080a65 1030 //The newest bin file is the one that is used by the mbed
leafman 98:9f8bab96edff 1031 sprintf(sTemp,"/local/fw%d.bin",fwCount);
TickTock 151:3047ebb3c9a8 1032 printf("Writing %s.\n",sTemp);
TickTock 160:905fe45ed54b 1033 //wait(2);
TickTock 143:88b5155622a5 1034 lfile = fopen(sTemp, "wb");
TickTock 143:88b5155622a5 1035 if(lfile == NULL)
leafman 98:9f8bab96edff 1036 {
TickTock 151:3047ebb3c9a8 1037 printf("Couldn't open destination.\n");
TickTock 160:905fe45ed54b 1038 wait(3);
leafman 98:9f8bab96edff 1039 return;
leafman 98:9f8bab96edff 1040 }
TickTock 97:a25940fd7b5b 1041
TickTock 143:88b5155622a5 1042 while (!f_eof(&efile))
leafman 98:9f8bab96edff 1043 {
TickTock 143:88b5155622a5 1044 sfr=f_read(&efile,&buffer,bufSize,&bytesRW);
TickTock 143:88b5155622a5 1045 fwrite(buffer, 1, bytesRW, lfile);
leafman 98:9f8bab96edff 1046 }
leafman 98:9f8bab96edff 1047
TickTock 143:88b5155622a5 1048 fflush(lfile);
TickTock 143:88b5155622a5 1049 fclose(lfile);
TickTock 143:88b5155622a5 1050 f_close(&efile);
TickTock 151:3047ebb3c9a8 1051 printf("Succesful.\n\n");
TickTock 152:a4d66901785d 1052 printf("Rebooting in 5 seconds.\n");
TickTock 152:a4d66901785d 1053 wait(5);
leafman 98:9f8bab96edff 1054 //Now run new firmware
TickTock 111:d1559bb25c43 1055 mbed_reset();
TickTock 99:c05abf8e1cdc 1056 }
TickTock 108:29b5a760adc2 1057
TickTock 169:84d790ac18a2 1058 void updateConfig()
TickTock 169:84d790ac18a2 1059 {
TickTock 169:84d790ac18a2 1060 FIL efile; // external usb file
TickTock 169:84d790ac18a2 1061 FRESULT sfr; // external file access flags
TickTock 169:84d790ac18a2 1062 unsigned int bytesRW;
TickTock 169:84d790ac18a2 1063 const int bufSize = 2048;
TickTock 169:84d790ac18a2 1064 char buffer[bufSize];
TickTock 169:84d790ac18a2 1065 FILE *lfile;
TickTock 169:84d790ac18a2 1066
TickTock 169:84d790ac18a2 1067 tt.set_font((unsigned char*) Arial12x12);
TickTock 169:84d790ac18a2 1068 tt.background(Blue);
TickTock 169:84d790ac18a2 1069 tt.foreground(Yellow);
TickTock 169:84d790ac18a2 1070 tt.locate(0,10);
TickTock 169:84d790ac18a2 1071 tt.cls();
TickTock 174:cd27e80f197d 1072
TickTock 174:cd27e80f197d 1073 printMsg("Copy config file from USB\n");
TickTock 169:84d790ac18a2 1074 // Check for config file on USB drive
TickTock 169:84d790ac18a2 1075 sfr = f_open(&efile,"CONFIG.TXT",FA_READ|FA_OPEN_EXISTING);
TickTock 169:84d790ac18a2 1076 if(sfr == FR_OK){
TickTock 169:84d790ac18a2 1077 printf("Copy config file from USB\n");
TickTock 169:84d790ac18a2 1078 lfile = fopen("/local/CONFIG.TXT", "w");
TickTock 169:84d790ac18a2 1079 if(lfile != NULL) {
TickTock 169:84d790ac18a2 1080 while (!f_eof(&efile)){
TickTock 169:84d790ac18a2 1081 sfr=f_read(&efile,&buffer,bufSize,&bytesRW);
TickTock 169:84d790ac18a2 1082 fwrite(buffer, 1, bytesRW, lfile);
TickTock 169:84d790ac18a2 1083 }
TickTock 169:84d790ac18a2 1084 fflush(lfile);
TickTock 169:84d790ac18a2 1085 fclose(lfile);
TickTock 169:84d790ac18a2 1086 }
TickTock 169:84d790ac18a2 1087 f_close(&efile);
TickTock 169:84d790ac18a2 1088 int fwc_tmp = fwCount;
TickTock 169:84d790ac18a2 1089 readConfig();
TickTock 169:84d790ac18a2 1090 fwCount = fwc_tmp; // Do no overwrite fwcount when loading new config
TickTock 169:84d790ac18a2 1091 }
TickTock 169:84d790ac18a2 1092
TickTock 169:84d790ac18a2 1093 // Check for history file on USB drive
TickTock 174:cd27e80f197d 1094 printMsg("Copy ehist file from USB\n");
TickTock 169:84d790ac18a2 1095 sfr = f_open(&efile,"ehist.cny",FA_READ|FA_OPEN_EXISTING);
TickTock 169:84d790ac18a2 1096 if(sfr == FR_OK){
TickTock 169:84d790ac18a2 1097 printf("Copy ehist file from USB\n");
TickTock 169:84d790ac18a2 1098 lfile = fopen("/local/ehist.cny", "w");
TickTock 169:84d790ac18a2 1099 if(lfile != NULL) {
TickTock 169:84d790ac18a2 1100 while (!f_eof(&efile)){
TickTock 169:84d790ac18a2 1101 sfr=f_read(&efile,&buffer,bufSize,&bytesRW);
TickTock 169:84d790ac18a2 1102 fwrite(buffer, 1, bytesRW, lfile);
TickTock 169:84d790ac18a2 1103 }
TickTock 169:84d790ac18a2 1104 fflush(lfile);
TickTock 169:84d790ac18a2 1105 fclose(lfile);
TickTock 169:84d790ac18a2 1106 }
TickTock 169:84d790ac18a2 1107 f_close(&efile);
TickTock 169:84d790ac18a2 1108 }
TickTock 169:84d790ac18a2 1109 printf("Succesful.\n\n");
TickTock 169:84d790ac18a2 1110 wait(5);
TickTock 169:84d790ac18a2 1111 }
TickTock 169:84d790ac18a2 1112
TickTock 108:29b5a760adc2 1113 bool detectUSB(void){
TickTock 130:1a9d2a6d99ce 1114 FIL tfile; // external usb file
TickTock 111:d1559bb25c43 1115 bool usbEn = (f_open(&tfile,"usb.det",FA_WRITE|FA_OPEN_ALWAYS)==FR_OK);
TickTock 108:29b5a760adc2 1116 if(usbEn){
TickTock 111:d1559bb25c43 1117 f_close(&tfile);
TickTock 111:d1559bb25c43 1118 f_unlink("usb.det");
TickTock 111:d1559bb25c43 1119 }
TickTock 130:1a9d2a6d99ce 1120 return(usbEn);
TickTock 108:29b5a760adc2 1121 }
TickTock 131:0d926c080a65 1122
TickTock 155:f31006516956 1123 void spkrOff(void){
TickTock 160:905fe45ed54b 1124 if(bCount<2){
TickTock 160:905fe45ed54b 1125 spkr.period(1.0/bFreq[bCount]);
TickTock 160:905fe45ed54b 1126 beepOff.attach(&spkrOff, bTime[bCount++]);
TickTock 160:905fe45ed54b 1127 }else{
TickTock 160:905fe45ed54b 1128 spkr=0;
TickTock 160:905fe45ed54b 1129 dled.period(.001);
TickTock 160:905fe45ed54b 1130 }
TickTock 155:f31006516956 1131 }
TickTock 155:f31006516956 1132
TickTock 155:f31006516956 1133 void beep(float freq, float time){
TickTock 155:f31006516956 1134 if (enableSound) {
TickTock 155:f31006516956 1135 spkr.period(1.0/freq);
TickTock 155:f31006516956 1136 spkr=0.5;
TickTock 159:577e9d015693 1137 if(!headlights){ //restore LCD pwm output (Beep pwm interferes with display pwm)
TickTock 155:f31006516956 1138 dled = ledHi;
TickTock 155:f31006516956 1139 } else {
TickTock 155:f31006516956 1140 dled = ledLo;
TickTock 155:f31006516956 1141 }
TickTock 155:f31006516956 1142 beepOff.attach(&spkrOff, time);
TickTock 155:f31006516956 1143 }
TickTock 155:f31006516956 1144 }
TickTock 155:f31006516956 1145
TickTock 160:905fe45ed54b 1146 void beep3(float freq1, float time1, float freq2, float time2, float freq3, float time3){
TickTock 160:905fe45ed54b 1147 bFreq[0]=freq2;
TickTock 160:905fe45ed54b 1148 bTime[0]=time2;
TickTock 160:905fe45ed54b 1149 bFreq[1]=freq3;
TickTock 160:905fe45ed54b 1150 bTime[1]=time3;
TickTock 160:905fe45ed54b 1151 bCount=0;
TickTock 160:905fe45ed54b 1152 beep(freq1, time1);
TickTock 160:905fe45ed54b 1153 }
TickTock 160:905fe45ed54b 1154
TickTock 140:ab3e94eb0227 1155 void chirp(void){
TickTock 140:ab3e94eb0227 1156 static unsigned short counter=0;
TickTock 140:ab3e94eb0227 1157
TickTock 140:ab3e94eb0227 1158 if(chirpInt>0){
TickTock 141:cf13a632ddb5 1159 if(++counter>chirpInt){
TickTock 155:f31006516956 1160 beep(1600,0.015);
TickTock 140:ab3e94eb0227 1161 counter=0;
TickTock 140:ab3e94eb0227 1162 }
TickTock 148:6e3b9135fad2 1163 }else{
TickTock 148:6e3b9135fad2 1164 counter=0;
TickTock 140:ab3e94eb0227 1165 }
TickTock 140:ab3e94eb0227 1166 }
TickTock 140:ab3e94eb0227 1167
TickTock 131:0d926c080a65 1168 //Sample CONFIG.TXT
TickTock 131:0d926c080a65 1169 /*
TickTock 174:cd27e80f197d 1170 format 11
TickTock 131:0d926c080a65 1171 x0_off 5732
TickTock 131:0d926c080a65 1172 y0_off 34009
TickTock 131:0d926c080a65 1173 x0_pp 77
TickTock 131:0d926c080a65 1174 y0_pp 106
TickTock 131:0d926c080a65 1175 x1_off 33955
TickTock 131:0d926c080a65 1176 y1_off 6310
TickTock 131:0d926c080a65 1177 x1_pp 80
TickTock 131:0d926c080a65 1178 y1_pp 104
TickTock 131:0d926c080a65 1179 x_mid 31986
TickTock 131:0d926c080a65 1180 dMode0 4
TickTock 131:0d926c080a65 1181 dMode1 2
TickTock 131:0d926c080a65 1182 ledHi 0.800
TickTock 150:ef46ce63345c 1183 ledLo 0.300
TickTock 131:0d926c080a65 1184 pollInt 300
TickTock 131:0d926c080a65 1185 scale12V 16.20
TickTock 131:0d926c080a65 1186 skin 0
TickTock 131:0d926c080a65 1187 dtePeriod 14
TickTock 131:0d926c080a65 1188 DebugMode 0
TickTock 144:b0c9d30dd346 1189 metric 0
TickTock 148:6e3b9135fad2 1190 firmware 1
TickTock 131:0d926c080a65 1191 showHealth 1
TickTock 141:cf13a632ddb5 1192 brakeMon 1
TickTock 174:cd27e80f197d 1193 brkMonRate 4.0
TickTock 174:cd27e80f197d 1194 brkMonThr 1.0
TickTock 150:ef46ce63345c 1195 usrMsgId 5103
TickTock 150:ef46ce63345c 1196 usrMsgId 50a3
TickTock 150:ef46ce63345c 1197 usrMsgId 54a4
TickTock 150:ef46ce63345c 1198 usrMsgId 54b4
TickTock 150:ef46ce63345c 1199 usrMsgId 54c0
TickTock 150:ef46ce63345c 1200 usrMsgId 55b4
TickTock 150:ef46ce63345c 1201 usrMsgId 0000
TickTock 150:ef46ce63345c 1202 usrMsgId 0000
TickTock 152:a4d66901785d 1203 modelYear 2011
TickTock 152:a4d66901785d 1204 autoSync 1
TickTock 174:cd27e80f197d 1205 kWperGid 0.075
TickTock 150:ef46ce63345c 1206 */