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@107:e9be732c1ad4, 2013-06-29 (annotated)

Committer:
TickTock
Date:
Sat Jun 29 02:44:02 2013 +0000
Branch:
Metric
Revision:
107:e9be732c1ad4
Parent:
106:f016912a03db
Child:
108:29b5a760adc2
Added trip meter

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 13:62e0f7f39ff5 3
TickTock 13:62e0f7f39ff5 4 void mbed_reset();
TickTock 22:a43df3905863 5
TickTock 13:62e0f7f39ff5 6 void RTC_IRQHandler() {
TickTock 13:62e0f7f39ff5 7 timer.reset(); // zero ms at the-seconds-tic
TickTock 20:3bf176d14b14 8 canIdle=(++secsNoMsg>canTimeout)?true:false;
TickTock 20:3bf176d14b14 9 userIdle=(++secsNoTouch>userTimeout)?true:false;
TickTock 13:62e0f7f39ff5 10 LPC_RTC->ILR |= (1<<0); // clear interrupt to prepare for next
TickTock 34:4751a8259b18 11 tick=true;
garygid 69:6bfdfc002036 12 // will use this to generate a logTP() just before the next Message received.
garygid 69:6bfdfc002036 13 if( (time(NULL) % 60) == 0) ZeroSecTick = true; // gg - at 0-second of each minute
TickTock 13:62e0f7f39ff5 14 }
TickTock 13:62e0f7f39ff5 15
TickTock 37:fea2c1d52c5f 16 void RTC_Init (void) {
TickTock 13:62e0f7f39ff5 17 LPC_RTC->ILR=0x00; // set up the RTC interrupts
TickTock 13:62e0f7f39ff5 18 LPC_RTC->CIIR=0x01; // interrupts each second
TickTock 13:62e0f7f39ff5 19 LPC_RTC->CCR = 0x01; // Clock enable
TickTock 92:935adef49ea4 20 //NVIC_SetPriority( RTC_IRQn, 10 );
TickTock 13:62e0f7f39ff5 21 NVIC_EnableIRQ( RTC_IRQn );
TickTock 13:62e0f7f39ff5 22 }
TickTock 13:62e0f7f39ff5 23
TickTock 93:c2402e8cd0e2 24 void printMsg (char *msg) {
TickTock 13:62e0f7f39ff5 25 strcpy(displayLog[displayLoc],msg);
TickTock 13:62e0f7f39ff5 26 displayLoc=displayLoc>17?0:displayLoc+1;
TickTock 13:62e0f7f39ff5 27 }
TickTock 13:62e0f7f39ff5 28
TickTock 13:62e0f7f39ff5 29 void touch_ISR(){
TickTock 37:fea2c1d52c5f 30 //LPC_GPIOINT->IO2IntClr = (LPC_GPIOINT->IO2IntStatR | LPC_GPIOINT->IO2IntStatF); // seems to work without so maybe not necessary (performed inInterruptIn handler?)
TickTock 35:5acbd8a64a89 31 touched=true; // just set flag - touch screen algorythm is long and we don't want to block other interrupts
TickTock 13:62e0f7f39ff5 32 }
TickTock 13:62e0f7f39ff5 33
TickTock 13:62e0f7f39ff5 34 unsigned short getTimeStamp() {
TickTock 13:62e0f7f39ff5 35 unsigned short msec = timer.read_ms() ; // read ms from the timer
TickTock 13:62e0f7f39ff5 36 unsigned long secs = time(NULL); // seconds past 12:00:00 AM 1 Jan 1900
TickTock 13:62e0f7f39ff5 37 unsigned short isecs = secs%60 ; // modulo 60 for 0-59 seconds from RTC
TickTock 13:62e0f7f39ff5 38 return ((isecs<<10)+msec) ; // return the two byte time stamp
TickTock 13:62e0f7f39ff5 39 }
TickTock 13:62e0f7f39ff5 40
TickTock 13:62e0f7f39ff5 41 void logCan (char mType, CANMessage canRXmsg) {
TickTock 85:5c27e88b3fbe 42
TickTock 85:5c27e88b3fbe 43 // re-arranged to put static first
TickTock 85:5c27e88b3fbe 44 static unsigned char ii = 0;
TickTock 85:5c27e88b3fbe 45 static unsigned char lasti = 0; // indexindex
TickTock 85:5c27e88b3fbe 46 static unsigned char bdi=0;
TickTock 85:5c27e88b3fbe 47 static signed short imotorRPM = 0;
TickTock 85:5c27e88b3fbe 48 static unsigned short nLost = 0; // gg - overrun
TickTock 85:5c27e88b3fbe 49
TickTock 83:52b1f330a62d 50 char sTemp[40];
TickTock 92:935adef49ea4 51 unsigned char changed;
TickTock 92:935adef49ea4 52 unsigned short i; // was unsigned char
TickTock 102:fd19f777a0b4 53 signed short j;
TickTock 92:935adef49ea4 54 signed short packV;
TickTock 92:935adef49ea4 55 signed short packA;
TickTock 40:0e6e71a7323f 56 signed long imWs_x4;
garygid 87:46ac3f2519d6 57 unsigned short ts;
TickTock 107:e9be732c1ad4 58 long temp_adc[6] = {1000,589,487,401,365,0 };
TickTock 107:e9be732c1ad4 59 signed short temp_C[6] = {-270, 130, 230, 320, 360, 760};
TickTock 85:5c27e88b3fbe 60
TickTock 36:dbd39c315258 61 secsNoMsg=0; // reset deadman switch
garygid 87:46ac3f2519d6 62 if(debugMode||(skin==ggSkin)){
garygid 87:46ac3f2519d6 63 // code to insert actual number of dropped frames for overrun debug - skiped in normal mode to keep logcan short
TickTock 85:5c27e88b3fbe 64 if(logOpen){
TickTock 106:f016912a03db 65 // check to see if buffer is already full (read - write) = 1
TickTock 106:f016912a03db 66 // actually the last buffer location cannot be used because then
TickTock 106:f016912a03db 67 // the buffer would look empty after writePointer++
TickTock 106:f016912a03db 68
TickTock 106:f016912a03db 69 //if (((writePointer+maxBufLen-readPointer)%maxBufLen)>(maxBufLen/16)) // modulo is slow?
TickTock 106:f016912a03db 70
TickTock 106:f016912a03db 71 // pointers are 0 through maxBufLen-1
TickTock 106:f016912a03db 72 if( (readPointer - writePointer) == 1 || (writePointer - readPointer) == (maxBufLen - 1)) {
TickTock 106:f016912a03db 73 // the buffer is "full", so Lose this message
TickTock 85:5c27e88b3fbe 74
TickTock 106:f016912a03db 75 // point to the last-stored message
TickTock 106:f016912a03db 76 int tempWritePointer = writePointer - 1 ;
TickTock 106:f016912a03db 77 if( tempWritePointer < 0 ) tempWritePointer = maxBufLen - 1;
TickTock 106:f016912a03db 78 char strLost[9] ;
TickTock 106:f016912a03db 79
TickTock 106:f016912a03db 80 if( nLost == 0 ) {
TickTock 106:f016912a03db 81 // this is the first message lost
TickTock 106:f016912a03db 82 // and we must overwrite the last message with an FFE comment message
TickTock 106:f016912a03db 83 // So, there will be two messages lost as the comment message is laid in.
TickTock 106:f016912a03db 84 nLost = 2;
TickTock 106:f016912a03db 85 sprintf(strLost,"%s","Lost0002"); // indicate two messages lost
TickTock 85:5c27e88b3fbe 86
TickTock 106:f016912a03db 87 // overlay the last message with a "Lost0002" comment
TickTock 106:f016912a03db 88 writeBuffer[tempWritePointer][0]=0;
TickTock 106:f016912a03db 89 // leave the ts of the overlaid message
TickTock 106:f016912a03db 90 //writeBuffer[tempWritePointer][1]=(ts&0xff00)>>8; // Time Stamp (2 bytes_
TickTock 106:f016912a03db 91 //writeBuffer[tempWritePointer][2]=(ts&0x00ff);
TickTock 106:f016912a03db 92 // force the MsgID to an Event Message
TickTock 106:f016912a03db 93 writeBuffer[tempWritePointer][3]=0xfe; // MsgID, low byte
TickTock 106:f016912a03db 94 writeBuffer[tempWritePointer][4]=0xff; // Len nibble, and MsgID high nibble
TickTock 106:f016912a03db 95 // lay in the "Lost0002" text
TickTock 106:f016912a03db 96 for(i=5;i<13;i++){
TickTock 106:f016912a03db 97 writeBuffer[tempWritePointer][i]= strLost[i-5];
TickTock 85:5c27e88b3fbe 98 }
TickTock 85:5c27e88b3fbe 99 } else {
TickTock 106:f016912a03db 100 // at least one message was previously lost
TickTock 106:f016912a03db 101 // increment the loat counter
TickTock 106:f016912a03db 102 nLost += 1;
garygid 87:46ac3f2519d6 103
TickTock 106:f016912a03db 104 // lay the new count into the comment
TickTock 106:f016912a03db 105 sprintf(strLost,"%04d",nLost);
TickTock 106:f016912a03db 106 for(i=9;i<13;i++){
TickTock 106:f016912a03db 107 writeBuffer[tempWritePointer][i]= strLost[i-9];
TickTock 85:5c27e88b3fbe 108 }
TickTock 106:f016912a03db 109 }
TickTock 106:f016912a03db 110 } else {
TickTock 106:f016912a03db 111 // there is room to insert the message
TickTock 106:f016912a03db 112 // get it inserted quickly
TickTock 106:f016912a03db 113 ts=getTimeStamp();
TickTock 106:f016912a03db 114 writeBuffer[writePointer][0]=mType;
TickTock 106:f016912a03db 115 writeBuffer[writePointer][1]=(ts&0xff00)>>8; // Time Stamp (2 bytes_
TickTock 106:f016912a03db 116 writeBuffer[writePointer][2]=(ts&0x00ff);
TickTock 106:f016912a03db 117 writeBuffer[writePointer][3]=canRXmsg.id&0xff; // MsgID, low byte
TickTock 106:f016912a03db 118 char sLen = canRXmsg.len ;
TickTock 106:f016912a03db 119 writeBuffer[writePointer][4]=(canRXmsg.id>>8)+(sLen<<4); // Len nibble, and MsgID high nibble
TickTock 106:f016912a03db 120 for(i=0;i<8;i++){ // Is there a better way to do this? (writeBuffer[writePointer][i]=canRXmsg.data?)
TickTock 106:f016912a03db 121 if(i<sLen)
TickTock 106:f016912a03db 122 writeBuffer[writePointer][i+5]=canRXmsg.data[i];
TickTock 106:f016912a03db 123 else // i>=sLen
TickTock 106:f016912a03db 124 // force unused data bytes to FF for CAN-Do compatibility
TickTock 106:f016912a03db 125 writeBuffer[writePointer][i+5]=0xFF;
TickTock 85:5c27e88b3fbe 126 }
TickTock 106:f016912a03db 127
TickTock 106:f016912a03db 128 //--------------
TickTock 106:f016912a03db 129 // Note, this is not protected from the interrupt.
TickTock 106:f016912a03db 130 // Due to the nLost code above, this no longer
TickTock 106:f016912a03db 131 // overflows to writePointer = readPointer
TickTock 106:f016912a03db 132 // which would make the buffer look empty
TickTock 106:f016912a03db 133 if (++writePointer >= maxBufLen) {
TickTock 106:f016912a03db 134 writePointer = 0;
TickTock 106:f016912a03db 135 led3 = !led3;
TickTock 106:f016912a03db 136 }
TickTock 106:f016912a03db 137 //--------------
TickTock 106:f016912a03db 138 // log a local message if we had lost messages. gg - logcan
TickTock 106:f016912a03db 139 if( nLost > 0 ) {
TickTock 106:f016912a03db 140 // We previously lost messages that did not get into the buffer
TickTock 106:f016912a03db 141 sprintf(sTemp,"-- Lost %d Messages.\n", nLost);
TickTock 106:f016912a03db 142 printMsg(sTemp); // write buffer overrun
TickTock 106:f016912a03db 143 //spkr.beep(500,0.25);
TickTock 106:f016912a03db 144
TickTock 106:f016912a03db 145 nLost = 0 ;
TickTock 106:f016912a03db 146 }
TickTock 106:f016912a03db 147 //--------------
TickTock 83:52b1f330a62d 148 }
TickTock 85:5c27e88b3fbe 149 }
TickTock 92:935adef49ea4 150 }else{ // not debugMode - keep code short
TickTock 85:5c27e88b3fbe 151 if(logOpen){
TickTock 106:f016912a03db 152 NVIC_DisableIRQ(CAN_IRQn); // Block interrupts until write pointer assigned
TickTock 106:f016912a03db 153 int localWritePointer = writePointer++; // create local copy to make logCan reentrant
TickTock 106:f016912a03db 154 // note that the static variables do not prevent safe reentry
TickTock 106:f016912a03db 155 // since they are only used for msgId<0x800 which will never interrupt
TickTock 106:f016912a03db 156 // another msgId<0x800 (both CANbusses are same priority)
TickTock 106:f016912a03db 157 if (writePointer >= maxBufLen) {
TickTock 106:f016912a03db 158 writePointer = 0;
TickTock 106:f016912a03db 159 led3 = !led3;
TickTock 106:f016912a03db 160 }
TickTock 106:f016912a03db 161 NVIC_EnableIRQ(CAN_IRQn); // Unblock interrupts once local pointer set and global pointer incremented
TickTock 106:f016912a03db 162 ts=getTimeStamp();
TickTock 106:f016912a03db 163 writeBuffer[localWritePointer][0]=mType;
TickTock 106:f016912a03db 164 writeBuffer[localWritePointer][1]=(ts&0xff00)>>8;
TickTock 106:f016912a03db 165 writeBuffer[localWritePointer][2]=(ts&0x00ff);
TickTock 106:f016912a03db 166 writeBuffer[localWritePointer][3]=canRXmsg.id&0xff;
TickTock 106:f016912a03db 167 writeBuffer[localWritePointer][4]=(canRXmsg.id>>8)+(canRXmsg.len<<4);
TickTock 106:f016912a03db 168 for(i=5;i<13;i++){ // Is there a better way to do this? (writeBuffer[localWritePointer][5]=canRXmsg.data?)
TickTock 106:f016912a03db 169 writeBuffer[localWritePointer][i]=canRXmsg.data[i-5];
TickTock 106:f016912a03db 170 }
TickTock 106:f016912a03db 171 if (writePointer==readPointer) {
TickTock 106:f016912a03db 172 // Just caught up to read pointer
TickTock 106:f016912a03db 173 sprintf(sTemp,"Write buffer overrun.\n");
TickTock 106:f016912a03db 174 printMsg(sTemp); // write buffer overrun
TickTock 106:f016912a03db 175 spkr.beep(500,0.25);
TickTock 13:62e0f7f39ff5 176 }
TickTock 13:62e0f7f39ff5 177 }
TickTock 37:fea2c1d52c5f 178 }
TickTock 40:0e6e71a7323f 179
TickTock 83:52b1f330a62d 180 if(canRXmsg.id<0x800){ // Block FFE and FFF messages
TickTock 83:52b1f330a62d 181 if(indexLastMsg[canRXmsg.id]==0) { //Check if no entry
TickTock 92:935adef49ea4 182 //ii=ii<99?ii+1:0; // Should never wrap - less than 100 different messages ever used
garygid 87:46ac3f2519d6 183 if(ii<99) {
TickTock 92:935adef49ea4 184 //indexLastMsg[canRXmsg.id]=ii; //Create entry if first message
garygid 87:46ac3f2519d6 185 indexLastMsg[canRXmsg.id]=++ii; //Create entry for first MsgID occurance
garygid 87:46ac3f2519d6 186 // ii max is 99 here
garygid 87:46ac3f2519d6 187 } else {
garygid 87:46ac3f2519d6 188 // the ii array is full, more than 100 MsgIDs found
garygid 87:46ac3f2519d6 189 if(ii==99) {
TickTock 92:935adef49ea4 190 ii++; // step to 100 to log only one error
garygid 87:46ac3f2519d6 191 sprintf(sTemp,"MsgID buffer overrun.\n");
TickTock 93:c2402e8cd0e2 192 printMsg(sTemp); // write buffer overrun
garygid 87:46ac3f2519d6 193 }
garygid 87:46ac3f2519d6 194 }
TickTock 83:52b1f330a62d 195 }
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 80:24f1793171e7 208
TickTock 83:52b1f330a62d 209 lastMsg[indexLastMsg[canRXmsg.id]]=canRXmsg; //Store in table
garygid 87:46ac3f2519d6 210
garygid 87:46ac3f2519d6 211 //-------------------
TickTock 83:52b1f330a62d 212 //Miscellaneous on-recieve operations below
TickTock 93:c2402e8cd0e2 213 if((mType==1)&&(canRXmsg.id==0x7bb)){ // is battery data? Need to store all responses
TickTock 83:52b1f330a62d 214 if(canRXmsg.data[0]<0x20){
garygid 87:46ac3f2519d6 215 if(canRXmsg.data[3]==2){//Group 2 = cellpair data
garygid 87:46ac3f2519d6 216 bdi=BatDataBaseG2; // index offset for CP data (uses 00 - 1C)
TickTock 97:a25940fd7b5b 217 if(debugMode){
TickTock 97:a25940fd7b5b 218 sprintf(sTemp," Getting cell pair data\n");
TickTock 97:a25940fd7b5b 219 printMsg(sTemp);
TickTock 97:a25940fd7b5b 220 }
garygid 87:46ac3f2519d6 221
garygid 87:46ac3f2519d6 222 }else if(canRXmsg.data[3]==4){//Group 4 = temperature data
garygid 87:46ac3f2519d6 223 bdi=BatDataBaseG4; // index offset for Temperature data (uses 20 - 22)
TickTock 97:a25940fd7b5b 224 if(debugMode){
TickTock 97:a25940fd7b5b 225 sprintf(sTemp," Getting temperature data\n");
TickTock 97:a25940fd7b5b 226 printMsg(sTemp);
TickTock 97:a25940fd7b5b 227 }
garygid 87:46ac3f2519d6 228
garygid 87:46ac3f2519d6 229 }else if(canRXmsg.data[3]==1){//Group 1 data
garygid 87:46ac3f2519d6 230 bdi=BatDataBaseG1; // index offset for Group 1 data (uses 20 - 22)
TickTock 97:a25940fd7b5b 231 if(debugMode){
TickTock 97:a25940fd7b5b 232 sprintf(sTemp," Getting Group 1 data\n");
TickTock 97:a25940fd7b5b 233 printMsg(sTemp);
TickTock 97:a25940fd7b5b 234 }
garygid 87:46ac3f2519d6 235
garygid 87:46ac3f2519d6 236 }else if(canRXmsg.data[3]==3){//Group 3 data
garygid 87:46ac3f2519d6 237 bdi=BatDataBaseG3; // index offset for Group 3 data (uses 20 - 22)
TickTock 97:a25940fd7b5b 238 if(debugMode){
TickTock 97:a25940fd7b5b 239 sprintf(sTemp," Getting Group 3 data\n");
TickTock 97:a25940fd7b5b 240 printMsg(sTemp);
TickTock 97:a25940fd7b5b 241 }
garygid 87:46ac3f2519d6 242
garygid 87:46ac3f2519d6 243 }else if(canRXmsg.data[3]==5){//Group 5 data
garygid 87:46ac3f2519d6 244 bdi=BatDataBaseG5; // index offset for Group 5 data (uses 20 - 22)
TickTock 97:a25940fd7b5b 245 if(debugMode){
TickTock 97:a25940fd7b5b 246 sprintf(sTemp," Getting Group 5 data\n");
TickTock 97:a25940fd7b5b 247 printMsg(sTemp);
TickTock 97:a25940fd7b5b 248 }
garygid 87:46ac3f2519d6 249
TickTock 83:52b1f330a62d 250 }else bdi=0xff; // ignore other messages (for now)
TickTock 83:52b1f330a62d 251 lasti=0;
TickTock 83:52b1f330a62d 252 }
garygid 87:46ac3f2519d6 253
TickTock 83:52b1f330a62d 254 if(bdi<0xff){
TickTock 83:52b1f330a62d 255 i=canRXmsg.data[0]&0x0f; //lower nibble of D0 is index
TickTock 83:52b1f330a62d 256 if(lasti>i){ //detect rollover and offset index appropriately
garygid 87:46ac3f2519d6 257 bdi=BatDataBaseG2 + 0x10; // only for CP data
TickTock 83:52b1f330a62d 258 }
TickTock 83:52b1f330a62d 259 lasti=i; //remember the msb to detect rollover next time around
TickTock 83:52b1f330a62d 260 i+=bdi;
garygid 87:46ac3f2519d6 261 //-------
TickTock 102:fd19f777a0b4 262 if(i==BatDataBaseG5){ // Last of Temperature data was loaded last time
TickTock 83:52b1f330a62d 263 logCP=yesBattLog; // Only log if logging enabled
TickTock 83:52b1f330a62d 264 showCP=true; // Always show
TickTock 102:fd19f777a0b4 265 // 2013 models only have three sensors
TickTock 102:fd19f777a0b4 266 battTemp_x4=battData[(BatDataBaseG4*7)+5]+battData[(BatDataBaseG4*7)+8]+battData[(BatDataBaseG4*7)+11]+battData[(BatDataBaseG4*7)+14];
TickTock 102:fd19f777a0b4 267 // Or =25+(467-ADC)/9.33 (C)
TickTock 102:fd19f777a0b4 268 // Find hottest temperature
TickTock 107:e9be732c1ad4 269 battTemp_x10=battData[(BatDataBaseG4*7)+3]*0x100+battData[(BatDataBaseG4*7)+4];
TickTock 107:e9be732c1ad4 270 j=battData[(BatDataBaseG4*7)+6]*0x100+battData[(BatDataBaseG4*7)+7];
TickTock 107:e9be732c1ad4 271 if(j<battTemp_x10){
TickTock 107:e9be732c1ad4 272 battTemp_x10=j;
TickTock 107:e9be732c1ad4 273 }
TickTock 107:e9be732c1ad4 274 j=battData[(BatDataBaseG4*7)+9]*0x100+battData[(BatDataBaseG4*7)+10];
TickTock 107:e9be732c1ad4 275 if(j<battTemp_x10){
TickTock 102:fd19f777a0b4 276 battTemp_x10=j;
TickTock 102:fd19f777a0b4 277 }
TickTock 107:e9be732c1ad4 278 j=battData[(BatDataBaseG4*7)+12]*0x100+battData[(BatDataBaseG4*7)+13];
TickTock 107:e9be732c1ad4 279 if(j<battTemp_x10){
TickTock 102:fd19f777a0b4 280 battTemp_x10=j;
TickTock 102:fd19f777a0b4 281 }
TickTock 107:e9be732c1ad4 282 //interpolate for temperature
TickTock 107:e9be732c1ad4 283 char k=0;
TickTock 107:e9be732c1ad4 284 while(battTemp_x10<=temp_adc[++k]) { } // Find section in table
TickTock 107:e9be732c1ad4 285 j=battTemp_x10-temp_adc[k];
TickTock 107:e9be732c1ad4 286 j*=(temp_C[k]-temp_C[k-1]);
TickTock 107:e9be732c1ad4 287 j/=(temp_adc[k]-temp_adc[k-1]);
TickTock 107:e9be732c1ad4 288 j+=temp_C[k];
TickTock 107:e9be732c1ad4 289 battTemp_x10=j;
TickTock 107:e9be732c1ad4 290 //battTemp_x10*=100;
TickTock 107:e9be732c1ad4 291 //battTemp_x10/=93;
TickTock 107:e9be732c1ad4 292 //battTemp_x10+=250;
TickTock 102:fd19f777a0b4 293 SOH_x100=battData[(BatDataBaseG1*7)+29]*0x100+battData[(BatDataBaseG1*7)+30];
TickTock 102:fd19f777a0b4 294 Ah_x10000=battData[(BatDataBaseG1*7)+36]*0x10000+battData[(BatDataBaseG1*7)+37]*0x100+battData[(BatDataBaseG1*7)+38];
TickTock 102:fd19f777a0b4 295 SOC_x10000=battData[(BatDataBaseG1*7)+32]*0x10000+battData[(BatDataBaseG1*7)+33]*0x100+battData[(BatDataBaseG1*7)+34];
TickTock 83:52b1f330a62d 296 }
garygid 87:46ac3f2519d6 297 //-------
TickTock 83:52b1f330a62d 298 i*=7;
garygid 87:46ac3f2519d6 299 if(i+6 < BatDataBufMax) {
TickTock 83:52b1f330a62d 300 battData[i+0]=canRXmsg.data[1];
TickTock 83:52b1f330a62d 301 battData[i+1]=canRXmsg.data[2];
TickTock 83:52b1f330a62d 302 battData[i+2]=canRXmsg.data[3];
TickTock 83:52b1f330a62d 303 battData[i+3]=canRXmsg.data[4];
TickTock 83:52b1f330a62d 304 battData[i+4]=canRXmsg.data[5];
TickTock 83:52b1f330a62d 305 battData[i+5]=canRXmsg.data[6];
TickTock 83:52b1f330a62d 306 battData[i+6]=canRXmsg.data[7];
TickTock 83:52b1f330a62d 307 }
TickTock 83:52b1f330a62d 308 }
TickTock 83:52b1f330a62d 309 }else if((mType==1)&&(canRXmsg.id==0x1db)){ //Battery Volts and Amps
TickTock 83:52b1f330a62d 310 packV=((canRXmsg.data[2]<<2)|(canRXmsg.data[3]>>6)); // 1 LSB = 0.5V
TickTock 83:52b1f330a62d 311 packA=((canRXmsg.data[0]<<3)|(canRXmsg.data[1]>>5)); // 1 LSB = 0.5A
TickTock 83:52b1f330a62d 312 if(packA>0x03ff){
TickTock 83:52b1f330a62d 313 packA|=0xf800;//extend sign;
TickTock 83:52b1f330a62d 314 }
TickTock 83:52b1f330a62d 315 packA -= 1; //Slight correction to value required (unique to my Leaf?)
TickTock 83:52b1f330a62d 316 imWs_x4 = packV; // Volts*milliSeconds*2
TickTock 83:52b1f330a62d 317 imWs_x4 *= -packA; // milliWattseconds*4
TickTock 97:a25940fd7b5b 318 //if (!((imotorRPM<2)&&(imWs_x4<0))){ //Ignore if charging from wall
TickTock 83:52b1f330a62d 319 mWs_x4 += imWs_x4; // total mWs_x4
TickTock 92:935adef49ea4 320 numWsamples++;
TickTock 97:a25940fd7b5b 321 //}
TickTock 83:52b1f330a62d 322 }else if((mType==1)&&(canRXmsg.id==0x1da)){ //Motor Speed
TickTock 83:52b1f330a62d 323 imotorRPM=((canRXmsg.data[4]<<8)|(canRXmsg.data[5]));
TickTock 83:52b1f330a62d 324 if(imotorRPM<0){ // take absolute value
TickTock 83:52b1f330a62d 325 imotorRPM=-imotorRPM;
TickTock 83:52b1f330a62d 326 }
TickTock 83:52b1f330a62d 327 motorRPM+=imotorRPM;
TickTock 92:935adef49ea4 328 numSsamples++;
TickTock 37:fea2c1d52c5f 329 }
TickTock 37:fea2c1d52c5f 330 }
TickTock 13:62e0f7f39ff5 331 }
TickTock 13:62e0f7f39ff5 332
garygid 87:46ac3f2519d6 333 //-----------------------------
TickTock 13:62e0f7f39ff5 334 void logTS () {
TickTock 13:62e0f7f39ff5 335 CANMessage tsMsg;
TickTock 13:62e0f7f39ff5 336 unsigned long secs = time(NULL); // seconds past 12:00:00 AM 1 Jan 1900
garygid 69:6bfdfc002036 337 // NOTE: In Mbed, I believe that this is seconds past start of 1970, not 1900
garygid 69:6bfdfc002036 338 // but this is good, since seconds past 1970 is what CAN-Do expects. GG - Date Time
TickTock 13:62e0f7f39ff5 339 tsMsg.id=0xfff;
TickTock 13:62e0f7f39ff5 340 tsMsg.len=0xf;
garygid 69:6bfdfc002036 341 tsMsg.data[0]=secs&0xff;
TickTock 13:62e0f7f39ff5 342 tsMsg.data[1]=(secs>>8)&0xff;
TickTock 13:62e0f7f39ff5 343 tsMsg.data[2]=(secs>>16)&0xff;
garygid 69:6bfdfc002036 344 tsMsg.data[3]=(secs>>24)&0xff;
garygid 69:6bfdfc002036 345 tsMsg.data[4]=0; // 0xff; gg - Date Time
garygid 69:6bfdfc002036 346 tsMsg.data[5]=0; // 0xff; for CAN-Do
garygid 69:6bfdfc002036 347 tsMsg.data[6]=0; // 0xff;
TickTock 13:62e0f7f39ff5 348 tsMsg.data[7]=0xff;
garygid 69:6bfdfc002036 349 logCan(0,tsMsg); // Date-Time
garygid 69:6bfdfc002036 350 }
garygid 69:6bfdfc002036 351
TickTock 93:c2402e8cd0e2 352 void logEvent (char * errMsg) {
garygid 69:6bfdfc002036 353 // log CAN-Do 8-character Pseudo Message
garygid 69:6bfdfc002036 354 CANMessage tsMsg;
garygid 69:6bfdfc002036 355 tsMsg.id=0xffe; // pseudo Message to CAN-Do log
garygid 69:6bfdfc002036 356 tsMsg.len=0xf;
TickTock 92:935adef49ea4 357 int iMsgLen = strlen(errMsg);
garygid 69:6bfdfc002036 358 // 8 character message compatible with CAN-Do
TickTock 92:935adef49ea4 359 for(int i=0; i<8; i++){
garygid 69:6bfdfc002036 360 tsMsg.data[i]=' ';
TickTock 92:935adef49ea4 361 if( i < iMsgLen ) tsMsg.data[i]=errMsg[i];
garygid 69:6bfdfc002036 362 }
garygid 69:6bfdfc002036 363 logCan(0,tsMsg); // FFE Comment Message
TickTock 13:62e0f7f39ff5 364 }
TickTock 13:62e0f7f39ff5 365
TickTock 78:a383971fe02f 366 void sendReq() {
TickTock 78:a383971fe02f 367 static char data[8] = {0x02, 0x21, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff};
TickTock 78:a383971fe02f 368 if(reqMsgCnt<99){
TickTock 92:935adef49ea4 369 switch (reqMsgCnt){
TickTock 102:fd19f777a0b4 370 case BatDataBaseG1:
TickTock 78:a383971fe02f 371 can1.monitor(false); // set to active mode
TickTock 78:a383971fe02f 372 can1SleepMode = 0; // enable TX
TickTock 83:52b1f330a62d 373 data[0]=0x02; //change to request group 1
TickTock 78:a383971fe02f 374 data[1]=0x21;
TickTock 78:a383971fe02f 375 data[2]=0x01;
TickTock 78:a383971fe02f 376 break;
TickTock 102:fd19f777a0b4 377 case BatDataBaseG2: // group 1 has 6 frames
TickTock 78:a383971fe02f 378 can1.monitor(false); // set to active mode
TickTock 78:a383971fe02f 379 can1SleepMode = 0; // enable TX
TickTock 83:52b1f330a62d 380 data[0]=0x02; //change to request group 2 (cp data)
TickTock 78:a383971fe02f 381 data[1]=0x21;
TickTock 78:a383971fe02f 382 data[2]=0x02;
TickTock 78:a383971fe02f 383 break;
TickTock 102:fd19f777a0b4 384 case BatDataBaseG3: // group 2 has 29 frames
TickTock 83:52b1f330a62d 385 data[0]=0x02; //change to request group 3
TickTock 78:a383971fe02f 386 data[1]=0x21;
TickTock 78:a383971fe02f 387 data[2]=0x03;
TickTock 78:a383971fe02f 388 break;
TickTock 102:fd19f777a0b4 389 case BatDataBaseG4: // group 3 has 5 frames
TickTock 83:52b1f330a62d 390 data[0]=0x02; //change to request group 4 (temperature)
TickTock 78:a383971fe02f 391 data[1]=0x21;
TickTock 78:a383971fe02f 392 data[2]=0x04;
TickTock 78:a383971fe02f 393 break;
TickTock 102:fd19f777a0b4 394 case BatDataBaseG5: // group 4 has 3 frames
TickTock 83:52b1f330a62d 395 data[0]=0x02; //change to request group 5
TickTock 78:a383971fe02f 396 data[1]=0x21;
TickTock 78:a383971fe02f 397 data[2]=0x05;
TickTock 78:a383971fe02f 398 break;
TickTock 102:fd19f777a0b4 399 case BatDataBaseG6: // group 5 has 11 frames
TickTock 78:a383971fe02f 400 reqMsgCnt = 99;
TickTock 78:a383971fe02f 401 can1SleepMode = 1; // disable TX
TickTock 78:a383971fe02f 402 can1.monitor(true); // set to snoop mode
TickTock 83:52b1f330a62d 403 msgReq.detach(); // stop ticker
TickTock 78:a383971fe02f 404 default:
TickTock 78:a383971fe02f 405 data[0]=0x30; //change to request next line message
TickTock 78:a383971fe02f 406 data[1]=0x01;
TickTock 78:a383971fe02f 407 data[2]=0x00;
TickTock 78:a383971fe02f 408 }
TickTock 78:a383971fe02f 409 can1.write(CANMessage(0x79b, data, 8));
TickTock 92:935adef49ea4 410 reqMsgCnt++;
TickTock 78:a383971fe02f 411 }
TickTock 78:a383971fe02f 412 }
TickTock 78:a383971fe02f 413
TickTock 78:a383971fe02f 414 void autoPollISR(){
TickTock 97:a25940fd7b5b 415 //char sTemp[40]; // just for debug
TickTock 97:a25940fd7b5b 416 //sprintf(sTemp,"Requesting cp data\n"); // just for debug
TickTock 97:a25940fd7b5b 417 //printMsg(sTemp); // just for debug
TickTock 78:a383971fe02f 418 reqMsgCnt = 0; //reset message counter
TickTock 94:c3a14b3975d6 419 msgReq.attach(&sendReq,0.015);
TickTock 78:a383971fe02f 420 }
garygid 87:46ac3f2519d6 421
TickTock 36:dbd39c315258 422 void playbackISR() { //Used for autoplayback
TickTock 36:dbd39c315258 423 step=true;
TickTock 36:dbd39c315258 424 }
TickTock 36:dbd39c315258 425
TickTock 36:dbd39c315258 426 void doNothing(){ //CAN deattach work-around
TickTock 36:dbd39c315258 427 }
TickTock 36:dbd39c315258 428
TickTock 13:62e0f7f39ff5 429 void recieve1() {
TickTock 13:62e0f7f39ff5 430 CANMessage msg1;
TickTock 13:62e0f7f39ff5 431 can1.read(msg1);
garygid 69:6bfdfc002036 432
garygid 69:6bfdfc002036 433 if( ZeroSecTick ) { ZeroSecTick = false; logTS(); } // gg - 0-second EV bus
TickTock 106:f016912a03db 434 if(msg1.id>0) {
TickTock 106:f016912a03db 435 logCan(1, msg1); // EVcan Message Received
TickTock 106:f016912a03db 436 led1 = !led1;
TickTock 106:f016912a03db 437 }
TickTock 13:62e0f7f39ff5 438 }
TickTock 13:62e0f7f39ff5 439
TickTock 13:62e0f7f39ff5 440 void recieve2() {
TickTock 13:62e0f7f39ff5 441 CANMessage msg2;
TickTock 13:62e0f7f39ff5 442 can2.read(msg2);
garygid 69:6bfdfc002036 443
garygid 69:6bfdfc002036 444 if( ZeroSecTick ) { ZeroSecTick = false; logTS(); } // gg - 0-second EV bus
garygid 69:6bfdfc002036 445
TickTock 106:f016912a03db 446 if(msg2.id>0) {
TickTock 106:f016912a03db 447 logCan(2, msg2); // CARcan Message Received
TickTock 106:f016912a03db 448 led2 = !led2;
TickTock 106:f016912a03db 449 }
TickTock 13:62e0f7f39ff5 450 }
TickTock 13:62e0f7f39ff5 451
TickTock 22:a43df3905863 452 unsigned char buttonX(unsigned short X, unsigned char columns) {
TickTock 22:a43df3905863 453 unsigned char val = X*columns/320;
TickTock 22:a43df3905863 454 return val;
TickTock 22:a43df3905863 455 }
TickTock 22:a43df3905863 456
TickTock 22:a43df3905863 457 unsigned char buttonY(unsigned short Y, unsigned char rows) {
TickTock 22:a43df3905863 458 unsigned short val = Y*rows/240;
TickTock 22:a43df3905863 459 return val;
TickTock 22:a43df3905863 460 }
TickTock 23:cd03f9c3395e 461
TickTock 23:cd03f9c3395e 462 void saveConfig(){
TickTock 23:cd03f9c3395e 463 FILE *cfile;
TickTock 99:c05abf8e1cdc 464 cfile = fopen("/local/config.txt", "w");
leafman 98:9f8bab96edff 465 fprintf(cfile,"format 5\r\n");
TickTock 23:cd03f9c3395e 466 fprintf(cfile,"x0_off %d\r\n",tt.x0_off);
TickTock 23:cd03f9c3395e 467 fprintf(cfile,"y0_off %d\r\n",tt.y0_off);
TickTock 23:cd03f9c3395e 468 fprintf(cfile,"x0_pp %d\r\n",tt.x0_pp);
TickTock 23:cd03f9c3395e 469 fprintf(cfile,"y0_pp %d\r\n",tt.y0_pp);
TickTock 23:cd03f9c3395e 470 fprintf(cfile,"x1_off %d\r\n",tt.x1_off);
TickTock 23:cd03f9c3395e 471 fprintf(cfile,"y1_off %d\r\n",tt.y1_off);
TickTock 23:cd03f9c3395e 472 fprintf(cfile,"x1_pp %d\r\n",tt.x1_pp);
TickTock 23:cd03f9c3395e 473 fprintf(cfile,"y1_pp %d\r\n",tt.y1_pp);
TickTock 23:cd03f9c3395e 474 fprintf(cfile,"x_mid %d\r\n",tt.x_mid);
leafman 98:9f8bab96edff 475 if (dMode[0]==configScreen)
TickTock 41:8d4609ea7259 476 fprintf(cfile,"dMode0 %d\r\n",mainScreen);
TickTock 26:462ccb580472 477 else
TickTock 26:462ccb580472 478 fprintf(cfile,"dMode0 %d\r\n",dMode[0]);
leafman 98:9f8bab96edff 479 if (dMode[1]==configScreen)
TickTock 41:8d4609ea7259 480 fprintf(cfile,"dMode1 %d\r\n",mainScreen);
TickTock 26:462ccb580472 481 else
TickTock 26:462ccb580472 482 fprintf(cfile,"dMode1 %d\r\n",dMode[1]);
TickTock 35:5acbd8a64a89 483 fprintf(cfile,"ledHi %4.3f\r\n",ledHi);
TickTock 35:5acbd8a64a89 484 fprintf(cfile,"ledLo %4.3f\r\n",ledLo);
TickTock 35:5acbd8a64a89 485 fprintf(cfile,"pollInt %d\r\n",pollInt);
TickTock 35:5acbd8a64a89 486 fprintf(cfile,"scale12V %4.2f\r\n",scale12V);
TickTock 48:d1ce92104a1f 487 fprintf(cfile,"skin %d\r\n",skin);
TickTock 50:83d5864c64a0 488 fprintf(cfile,"dtePeriod %d\r\n",dtePeriod);
garygid 87:46ac3f2519d6 489 fprintf(cfile,"DebugMode %d\r\n",(debugMode?1:0));
leafman 98:9f8bab96edff 490 fprintf(cfile,"metric %d\r\n",(metric?1:0));
leafman 98:9f8bab96edff 491 fprintf(cfile, "firmware %d\r\n", fwCount );
TickTock 23:cd03f9c3395e 492 fclose(cfile);
TickTock 23:cd03f9c3395e 493 }
TickTock 23:cd03f9c3395e 494
TickTock 23:cd03f9c3395e 495 void readConfig(){
TickTock 23:cd03f9c3395e 496 FILE *cfile;
TickTock 23:cd03f9c3395e 497 int ff;
TickTock 23:cd03f9c3395e 498 char sTemp[40];
TickTock 23:cd03f9c3395e 499 cfile = fopen("/local/config.txt", "r");
TickTock 23:cd03f9c3395e 500 if (cfile==NULL){ // if doesn't exist --> create
TickTock 23:cd03f9c3395e 501 sprintf(sTemp,"No config file found.\n");
TickTock 93:c2402e8cd0e2 502 printMsg(sTemp); // no config file
TickTock 23:cd03f9c3395e 503 sprintf(sTemp,"Calibrating touch screen.\n");
TickTock 93:c2402e8cd0e2 504 printMsg(sTemp); // calibrating
TickTock 23:cd03f9c3395e 505 //tt.setcal(5570, 34030, 80, 108, 33700, 5780, 82, 108, 32500);// bypass calibration using my values
TickTock 23:cd03f9c3395e 506 tt.calibrate(); // run touchscreen calibration routine
garygid 58:4d06288d75a2 507 // NOTE: calibrates screen 1 first, then screen 0.
TickTock 23:cd03f9c3395e 508 saveConfig();
TickTock 23:cd03f9c3395e 509 } else {
TickTock 102:fd19f777a0b4 510 ledHi = 0.8;
TickTock 48:d1ce92104a1f 511 ledLo = 0.1;
TickTock 102:fd19f777a0b4 512 pollInt = 60;
TickTock 48:d1ce92104a1f 513 scale12V = 16.2;
TickTock 48:d1ce92104a1f 514 skin = ttSkin;
leafman 98:9f8bab96edff 515 fscanf(cfile, "format %d\r\n", &ff );
leafman 98:9f8bab96edff 516 fscanf(cfile, "x0_off %d\r\n", &tt.x0_off );
leafman 98:9f8bab96edff 517 fscanf(cfile, "y0_off %d\r\n", &tt.y0_off );
leafman 98:9f8bab96edff 518 fscanf(cfile, "x0_pp %d\r\n", &tt.x0_pp );
leafman 98:9f8bab96edff 519 fscanf(cfile, "y0_pp %d\r\n", &tt.y0_pp );
leafman 98:9f8bab96edff 520 fscanf(cfile, "x1_off %d\r\n", &tt.x1_off );
leafman 98:9f8bab96edff 521 fscanf(cfile, "y1_off %d\r\n", &tt.y1_off );
leafman 98:9f8bab96edff 522 fscanf(cfile, "x1_pp %d\r\n", &tt.x1_pp );
leafman 98:9f8bab96edff 523 fscanf(cfile, "y1_pp %d\r\n", &tt.y1_pp );
leafman 98:9f8bab96edff 524 fscanf(cfile, "x_mid %d\r\n", &tt.x_mid );
leafman 98:9f8bab96edff 525 fscanf(cfile, "dMode0 %d\r\n", &dMode[0] );
leafman 98:9f8bab96edff 526 fscanf(cfile, "dMode1 %d\r\n", &dMode[1] );
TickTock 35:5acbd8a64a89 527 if(ff>1){
leafman 98:9f8bab96edff 528 fscanf(cfile, "ledHi %f\r\n", &ledHi );
leafman 98:9f8bab96edff 529 fscanf(cfile, "ledLo %f\r\n", &ledLo );
leafman 98:9f8bab96edff 530 fscanf(cfile, "pollInt %d\r\n", &pollInt );
leafman 98:9f8bab96edff 531 fscanf(cfile, "scale12V %f\r\n", &scale12V );
TickTock 48:d1ce92104a1f 532 }
TickTock 48:d1ce92104a1f 533 if(ff>2){
leafman 98:9f8bab96edff 534 fscanf(cfile, "skin %d\r\n", &skin );
leafman 98:9f8bab96edff 535 fscanf(cfile, "dtePeriod %d\r\n", &dtePeriod );
TickTock 35:5acbd8a64a89 536 }
garygid 87:46ac3f2519d6 537 if(ff>3){
leafman 98:9f8bab96edff 538 int iDebug;
leafman 98:9f8bab96edff 539 fscanf(cfile, "DebugMode %d\r\n", &iDebug );
leafman 98:9f8bab96edff 540 debugMode = (bool)iDebug;
leafman 98:9f8bab96edff 541 }
leafman 98:9f8bab96edff 542 if(ff>4) {
leafman 98:9f8bab96edff 543 int iMetric;
leafman 98:9f8bab96edff 544 fscanf(cfile, "metric %d\r\n", &iMetric );
leafman 98:9f8bab96edff 545 metric = (bool)iMetric;
leafman 98:9f8bab96edff 546 fscanf(cfile, "firmware %d\r\n", &iMetric );
leafman 98:9f8bab96edff 547 fwCount = iMetric;
garygid 87:46ac3f2519d6 548 }
TickTock 23:cd03f9c3395e 549 fclose(cfile);
garygid 87:46ac3f2519d6 550 if(ff<4){//If not latest format, save as latest format
TickTock 35:5acbd8a64a89 551 saveConfig();
TickTock 48:d1ce92104a1f 552 sprintf(sTemp,"Config file format updated.\n");
TickTock 93:c2402e8cd0e2 553 printMsg(sTemp); // config forat updates
TickTock 48:d1ce92104a1f 554 }
TickTock 43:e7f6f80590e3 555 sprintf(sTemp,"Config file loaded.\n");
TickTock 93:c2402e8cd0e2 556 printMsg(sTemp); // config file loaded
TickTock 23:cd03f9c3395e 557 }
TickTock 23:cd03f9c3395e 558 }
TickTock 25:ddf0ec209f03 559
TickTock 25:ddf0ec209f03 560 void upDate(unsigned char field, bool upDownBar){
TickTock 25:ddf0ec209f03 561 struct tm t; // pointer to a static tm structure
TickTock 25:ddf0ec209f03 562 time_t seconds ;
TickTock 25:ddf0ec209f03 563 seconds = time(NULL);
TickTock 25:ddf0ec209f03 564 t = *localtime(&seconds) ;
TickTock 25:ddf0ec209f03 565 switch(field){
TickTock 25:ddf0ec209f03 566 case 0: // year
TickTock 25:ddf0ec209f03 567 if (upDownBar) {
TickTock 25:ddf0ec209f03 568 t.tm_year = t.tm_year+1;
TickTock 25:ddf0ec209f03 569 } else {
TickTock 25:ddf0ec209f03 570 t.tm_year = t.tm_year-1;
TickTock 25:ddf0ec209f03 571 }
TickTock 25:ddf0ec209f03 572 break;
TickTock 25:ddf0ec209f03 573 case 1: // month
TickTock 25:ddf0ec209f03 574 if (upDownBar) {
TickTock 25:ddf0ec209f03 575 t.tm_mon = (t.tm_mon<12)?t.tm_mon+1:1;
TickTock 25:ddf0ec209f03 576 } else {
TickTock 25:ddf0ec209f03 577 t.tm_mon = (t.tm_mon>2)?t.tm_mon-1:12;
TickTock 25:ddf0ec209f03 578 }
TickTock 25:ddf0ec209f03 579 break;
TickTock 25:ddf0ec209f03 580 case 2: // day
TickTock 25:ddf0ec209f03 581 if (upDownBar) {
TickTock 25:ddf0ec209f03 582 t.tm_mday = (t.tm_mday<31)?t.tm_mday+1:1;
TickTock 25:ddf0ec209f03 583 } else {
TickTock 25:ddf0ec209f03 584 t.tm_mday = (t.tm_mday>2)?t.tm_mday-1:31;
TickTock 25:ddf0ec209f03 585 }
TickTock 25:ddf0ec209f03 586 break;
TickTock 25:ddf0ec209f03 587 case 3: // hour
TickTock 25:ddf0ec209f03 588 if (upDownBar) {
TickTock 25:ddf0ec209f03 589 t.tm_hour = (t.tm_hour<23)?t.tm_hour+1:0;
TickTock 25:ddf0ec209f03 590 } else {
TickTock 25:ddf0ec209f03 591 t.tm_hour = (t.tm_hour>1)?t.tm_hour-1:23;
TickTock 25:ddf0ec209f03 592 }
TickTock 25:ddf0ec209f03 593 break;
TickTock 25:ddf0ec209f03 594 case 4: // minute
TickTock 25:ddf0ec209f03 595 if (upDownBar) {
TickTock 25:ddf0ec209f03 596 t.tm_min = (t.tm_min<59)?t.tm_min+1:0;
TickTock 25:ddf0ec209f03 597 } else {
TickTock 25:ddf0ec209f03 598 t.tm_min = (t.tm_min>1)?t.tm_min-1:59;
TickTock 25:ddf0ec209f03 599 }
TickTock 25:ddf0ec209f03 600 break;
TickTock 25:ddf0ec209f03 601 case 5: // second
TickTock 25:ddf0ec209f03 602 if (upDownBar) {
TickTock 25:ddf0ec209f03 603 t.tm_sec = (t.tm_sec<59)?t.tm_sec+1:0;
TickTock 25:ddf0ec209f03 604 } else {
TickTock 25:ddf0ec209f03 605 t.tm_sec = (t.tm_sec>1)?t.tm_sec-1:59;
TickTock 25:ddf0ec209f03 606 }
TickTock 25:ddf0ec209f03 607 break;
TickTock 25:ddf0ec209f03 608 default:
TickTock 25:ddf0ec209f03 609 break;
TickTock 25:ddf0ec209f03 610 }
TickTock 25:ddf0ec209f03 611 set_time(mktime(&t));
TickTock 25:ddf0ec209f03 612 }
TickTock 25:ddf0ec209f03 613
TickTock 39:eef8beac7411 614 void logPackVoltages() { // Turbo3 - routine to dump CP values to text file
TickTock 39:eef8beac7411 615 char sTemp[40];
TickTock 39:eef8beac7411 616 struct tm t; // pointer to a static tm structure
TickTock 39:eef8beac7411 617 short unsigned max, min, jv, i, bd;
TickTock 39:eef8beac7411 618 unsigned avg;
TickTock 39:eef8beac7411 619 unsigned short gids, SOC, packV;
TickTock 39:eef8beac7411 620 signed short packA;
TickTock 39:eef8beac7411 621 time_t seconds ;
TickTock 39:eef8beac7411 622
TickTock 39:eef8beac7411 623 CANMessage msg;
TickTock 39:eef8beac7411 624
TickTock 39:eef8beac7411 625 seconds = time(NULL); // Turbo3
TickTock 39:eef8beac7411 626 t = *localtime(&seconds) ; // Turbo3
TickTock 39:eef8beac7411 627
TickTock 39:eef8beac7411 628 msg = lastMsg[indexLastMsg[0x5bc]]; //Get gids
TickTock 39:eef8beac7411 629 gids = (msg.data[0]<<2)+(msg.data[1]>>6);
TickTock 39:eef8beac7411 630 msg = lastMsg[indexLastMsg[0x55b]]; //Get SOC
TickTock 39:eef8beac7411 631 SOC = (msg.data[0]<<2)+(msg.data[1]>>6);
TickTock 39:eef8beac7411 632 msg = lastMsg[indexLastMsg[0x1db]]; //Get pack volts
TickTock 39:eef8beac7411 633 packV = (msg.data[2]<<2)+(msg.data[3]>>6);
TickTock 39:eef8beac7411 634 packA = (msg.data[0]<<3)+(msg.data[1]>>5);
TickTock 39:eef8beac7411 635 if (packA & 0x400) packA |= 0xf800;
TickTock 39:eef8beac7411 636
TickTock 39:eef8beac7411 637 max=0;
TickTock 39:eef8beac7411 638 min=9999;
TickTock 39:eef8beac7411 639 avg=0;
TickTock 92:935adef49ea4 640 for(i=0; i<96; i++) {
TickTock 39:eef8beac7411 641 bd=(battData[i*2+3]<<8)+battData[i*2+4];
TickTock 39:eef8beac7411 642 avg+=bd;
TickTock 39:eef8beac7411 643 if(bd>max) max=bd;
TickTock 39:eef8beac7411 644 if(bd<min) min=bd;
TickTock 39:eef8beac7411 645 }
TickTock 39:eef8beac7411 646 avg /= 96;
TickTock 39:eef8beac7411 647 if(min<3713) {
TickTock 39:eef8beac7411 648 jv=avg-(max-avg)*1.5;
TickTock 39:eef8beac7411 649 } else { // Only compute judgement value if min cellpair meets <= 3712mV requirement
TickTock 39:eef8beac7411 650 jv=0;
TickTock 39:eef8beac7411 651 }
TickTock 39:eef8beac7411 652
TickTock 39:eef8beac7411 653 FILE *bfile;
TickTock 39:eef8beac7411 654 //bfile = fopen("/local/batvolt.txt", "a");
TickTock 39:eef8beac7411 655 bfile = fopen("/usb/batvolt.txt", "a");
TickTock 39:eef8beac7411 656 if(bfile!=NULL) {
TickTock 39:eef8beac7411 657 strftime(sTemp, 40, "%a %m/%d/%Y %X", &t);
TickTock 39:eef8beac7411 658 fprintf(bfile,"%s,%d,%5.1f%%,%5.1f,%5.1f,%d,%d,%d,%d,%d",sTemp,gids,(float)SOC/10,(float)packV/2,(float)packA/2,max,min,avg,max-min,jv);
TickTock 102:fd19f777a0b4 659 // BatDataBaseG4 * 7 = (BatDataBaseG4*7)
TickTock 102:fd19f777a0b4 660 fprintf(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 102:fd19f777a0b4 661 fprintf(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 92:935adef49ea4 662 for(i=0; i<96; i++) {
TickTock 39:eef8beac7411 663 bd=(battData[i*2+3]<<8)+battData[i*2+4];
TickTock 39:eef8beac7411 664 fprintf(bfile,",%d",bd);
TickTock 39:eef8beac7411 665 }
TickTock 39:eef8beac7411 666 fprintf(bfile,"\r\n");
TickTock 39:eef8beac7411 667 fclose(bfile);
TickTock 39:eef8beac7411 668 }
TickTock 39:eef8beac7411 669 logCP=false;
TickTock 40:0e6e71a7323f 670 showCP=true;
TickTock 39:eef8beac7411 671 }
TickTock 25:ddf0ec209f03 672
leafman 98:9f8bab96edff 673 //LM - updates firmware off a usb key, eliminating the need to plug
leafman 98:9f8bab96edff 674 //the CANary into a computer for updates.
leafman 98:9f8bab96edff 675 void updateFirmware()
leafman 98:9f8bab96edff 676 {
TickTock 99:c05abf8e1cdc 677 char sTemp[40];
TickTock 99:c05abf8e1cdc 678 FILE *srcFile;
TickTock 99:c05abf8e1cdc 679 srcFile = fopen("/usb/firmware.bin", "rb");
TickTock 99:c05abf8e1cdc 680 if(srcFile ==NULL)
TickTock 99:c05abf8e1cdc 681 {
TickTock 99:c05abf8e1cdc 682 sprintf(sTemp,"Couldn't find firmware.bin\n");
TickTock 99:c05abf8e1cdc 683 printf(sTemp);
TickTock 99:c05abf8e1cdc 684 wait(5);
TickTock 100:63a7456fc972 685 lastDMode[whichTouched]=99;//force refresh
TickTock 99:c05abf8e1cdc 686 return;
TickTock 99:c05abf8e1cdc 687 }
leafman 98:9f8bab96edff 688 fwCount ++;
leafman 98:9f8bab96edff 689 saveConfig();
leafman 98:9f8bab96edff 690 tt.cls();
leafman 98:9f8bab96edff 691 printf("Saved Configuration\n");
leafman 98:9f8bab96edff 692 //delete all bin files in /local
leafman 98:9f8bab96edff 693 DIR *dir;
leafman 98:9f8bab96edff 694 struct dirent *ent;
leafman 98:9f8bab96edff 695 printf("Starting update\n");
leafman 98:9f8bab96edff 696 printf("deleting old firmware files\n");
leafman 98:9f8bab96edff 697 if ((dir = opendir ("/local/")) != NULL) {
leafman 98:9f8bab96edff 698 /* print all the files and directories within directory */
leafman 98:9f8bab96edff 699 while ((ent = readdir (dir)) != NULL) {
leafman 98:9f8bab96edff 700 //printf("FILE: %s\n",ent->d_name);
leafman 98:9f8bab96edff 701 char dest[4] = "";
leafman 98:9f8bab96edff 702 strncat(dest, &ent->d_name[strlen(ent->d_name)-3],3);
leafman 98:9f8bab96edff 703 dest[0] = tolower(dest[0]);
leafman 98:9f8bab96edff 704 dest[1] = tolower(dest[1]);
leafman 98:9f8bab96edff 705 dest[2] = tolower(dest[2]);
leafman 98:9f8bab96edff 706 if(strcmp(dest,"bin")==0)
leafman 98:9f8bab96edff 707 {
leafman 98:9f8bab96edff 708 sprintf(sTemp,"/local/%s",ent->d_name);
leafman 98:9f8bab96edff 709 int result = remove(sTemp);
leafman 98:9f8bab96edff 710 printf("REMOVED: %s",ent->d_name);
leafman 98:9f8bab96edff 711 }
leafman 98:9f8bab96edff 712 }
leafman 98:9f8bab96edff 713 closedir (dir);
leafman 98:9f8bab96edff 714 } else {
leafman 98:9f8bab96edff 715 /* could not open directory */
leafman 98:9f8bab96edff 716 printf("Couldnt open folder");
leafman 98:9f8bab96edff 717 wait(5);
leafman 98:9f8bab96edff 718 return;
leafman 98:9f8bab96edff 719 }
leafman 98:9f8bab96edff 720 printf("copying new firmware\n");
leafman 98:9f8bab96edff 721 tt.cls();
leafman 98:9f8bab96edff 722 //Copy the new firmware from usb->local
leafman 98:9f8bab96edff 723 //The newest bin file is the one that is used by the mbed
leafman 98:9f8bab96edff 724 const int bufSize = 2048;
leafman 98:9f8bab96edff 725 FILE *destFile;
leafman 98:9f8bab96edff 726 sprintf(sTemp,"/local/fw%d.bin",fwCount);
leafman 98:9f8bab96edff 727 printf("Writing %s\n",sTemp);
leafman 98:9f8bab96edff 728 wait(2);
leafman 98:9f8bab96edff 729 destFile = fopen(sTemp, "wb");
leafman 98:9f8bab96edff 730 if(destFile == NULL)
leafman 98:9f8bab96edff 731 {
leafman 98:9f8bab96edff 732 sprintf(sTemp,"Couldn't Open Destination\n");
leafman 98:9f8bab96edff 733 printf(sTemp);
leafman 98:9f8bab96edff 734 wait(5);
leafman 98:9f8bab96edff 735 return;
leafman 98:9f8bab96edff 736 }
leafman 98:9f8bab96edff 737 char buffer[bufSize];
TickTock 97:a25940fd7b5b 738
leafman 98:9f8bab96edff 739 while (!feof(srcFile))
leafman 98:9f8bab96edff 740 {
leafman 98:9f8bab96edff 741 int n = fread(buffer, 1, bufSize, srcFile);
leafman 98:9f8bab96edff 742 fwrite(buffer, 1, n, destFile);
leafman 98:9f8bab96edff 743 }
leafman 98:9f8bab96edff 744
leafman 98:9f8bab96edff 745 fflush(destFile);
leafman 98:9f8bab96edff 746 fclose(destFile);
leafman 98:9f8bab96edff 747 fclose(srcFile);
leafman 98:9f8bab96edff 748 tt.cls();
leafman 98:9f8bab96edff 749 printf("Succesful\n\n");
leafman 98:9f8bab96edff 750 printf("Rebooting in 5 seconds\n");
leafman 98:9f8bab96edff 751 wait(5);
leafman 98:9f8bab96edff 752 //Now run new firmware
leafman 98:9f8bab96edff 753 mbed_reset();
TickTock 99:c05abf8e1cdc 754 }