Tick Tock / Mbed 2 deprecated default

Dual CANbus monitor and instrumentation cluster

Dependencies:   SPI_TFTx2 TFT_fonts TOUCH_TFTx2 beep mbed

Fork of CANary by Tick Tock

utility.cpp@123:a8c0042df617, 2013-07-19 (annotated)

Committer:
TickTock
Date:
Fri Jul 19 12:48:10 2013 +0000
Branch:
Metric
Revision:
123:a8c0042df617
Parent:
122:138a40892a4c
Child:
124:0d622967b764
First attempt to add tire pressure

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