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@148:6e3b9135fad2, 2013-09-12 (annotated)

Committer:
TickTock
Date:
Thu Sep 12 14:42:22 2013 +0000
Revision:
148:6e3b9135fad2
Parent:
147:e0f1c84c62a6
Child:
149:e9739523109f
// No longer save config after firmware update; // Added config health check after read; // Added debugScreen; // Switched friction monitor to msgId:292 so MY2013 will work; // Added ambient to main display; // Added Resr to trip log

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