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@89:2263d349b484, 2013-04-20 (annotated)

Committer:
TickTock
Date:
Sat Apr 20 19:30:10 2013 +0000
Revision:
89:2263d349b484
Parent:
88:45185a5f1c9b
Child:
91:33ab084a184f
Moved headlight detection out of logCan.

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 13:62e0f7f39ff5 20 //NVIC_SetPriority( RTC_IRQn, 10 );
TickTock 13:62e0f7f39ff5 21 NVIC_EnableIRQ( RTC_IRQn );
TickTock 13:62e0f7f39ff5 22 }
TickTock 13:62e0f7f39ff5 23
TickTock 88:45185a5f1c9b 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];
garygid 87:46ac3f2519d6 51 unsigned char changed;
garygid 87:46ac3f2519d6 52 unsigned short i; // was unsigned char
TickTock 40:0e6e71a7323f 53 signed short packV;
TickTock 37:fea2c1d52c5f 54 signed short packA;
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 85:5c27e88b3fbe 62 if(canRXmsg.id>0) {
TickTock 85:5c27e88b3fbe 63 // check to see if buffer is already full (read - write) = 1
TickTock 85:5c27e88b3fbe 64 // actually the last buffer location cannot be used because then
TickTock 85:5c27e88b3fbe 65 // the buffer would look empty after writePointer++
TickTock 85:5c27e88b3fbe 66
TickTock 85:5c27e88b3fbe 67 //if (((writePointer+maxBufLen-readPointer)%maxBufLen)>(maxBufLen/16)) // modulo is slow?
TickTock 85:5c27e88b3fbe 68
garygid 87:46ac3f2519d6 69 // pointers are 0 through maxBufLen-1
TickTock 85:5c27e88b3fbe 70 if( (readPointer - writePointer) == 1 || (writePointer - readPointer) == (maxBufLen - 1)) {
TickTock 85:5c27e88b3fbe 71 // the buffer is "full", so Lose this message
TickTock 85:5c27e88b3fbe 72
TickTock 85:5c27e88b3fbe 73 // point to the last-stored message
TickTock 85:5c27e88b3fbe 74 int tempWritePointer = writePointer - 1 ;
garygid 87:46ac3f2519d6 75 if( tempWritePointer < 0 ) tempWritePointer = maxBufLen - 1;
TickTock 85:5c27e88b3fbe 76 char strLost[9] ;
TickTock 85:5c27e88b3fbe 77
TickTock 85:5c27e88b3fbe 78 if( nLost == 0 ) {
TickTock 85:5c27e88b3fbe 79 // this is the first message lost
TickTock 85:5c27e88b3fbe 80 // and we must overwrite the last message with an FFE comment message
TickTock 85:5c27e88b3fbe 81 // So, there will be two messages lost as the comment message is laid in.
TickTock 85:5c27e88b3fbe 82 nLost = 2;
TickTock 85:5c27e88b3fbe 83 sprintf(strLost,"%s","Lost0002"); // indicate two messages lost
TickTock 85:5c27e88b3fbe 84
TickTock 85:5c27e88b3fbe 85 // overlay the last message with a "Lost0002" comment
TickTock 85:5c27e88b3fbe 86 writeBuffer[tempWritePointer][0]=0;
garygid 87:46ac3f2519d6 87 // leave the ts of the overlaid message
garygid 87:46ac3f2519d6 88 //writeBuffer[tempWritePointer][1]=(ts&0xff00)>>8; // Time Stamp (2 bytes_
garygid 87:46ac3f2519d6 89 //writeBuffer[tempWritePointer][2]=(ts&0x00ff);
garygid 87:46ac3f2519d6 90 // force the MsgID to an Event Message
TickTock 85:5c27e88b3fbe 91 writeBuffer[tempWritePointer][3]=0xfe; // MsgID, low byte
TickTock 85:5c27e88b3fbe 92 writeBuffer[tempWritePointer][4]=0xff; // Len nibble, and MsgID high nibble
garygid 87:46ac3f2519d6 93 // lay in the "Lost0002" text
TickTock 89:2263d349b484 94 for(i=5;i<13;++i){
TickTock 85:5c27e88b3fbe 95 writeBuffer[tempWritePointer][i]= strLost[i-5];
TickTock 85:5c27e88b3fbe 96 }
TickTock 85:5c27e88b3fbe 97 } else {
garygid 87:46ac3f2519d6 98 // at least one message was previously lost
TickTock 85:5c27e88b3fbe 99 // increment the loat counter
TickTock 85:5c27e88b3fbe 100 nLost += 1;
TickTock 85:5c27e88b3fbe 101
TickTock 85:5c27e88b3fbe 102 // lay the new count into the comment
TickTock 85:5c27e88b3fbe 103 sprintf(strLost,"%04d",nLost);
TickTock 89:2263d349b484 104 for(i=9;i<13;++i){
TickTock 85:5c27e88b3fbe 105 writeBuffer[tempWritePointer][i]= strLost[i-9];
TickTock 85:5c27e88b3fbe 106 }
TickTock 85:5c27e88b3fbe 107 }
TickTock 85:5c27e88b3fbe 108 } else {
garygid 87:46ac3f2519d6 109 // there is room to insert the message
TickTock 85:5c27e88b3fbe 110 // get it inserted quickly
garygid 87:46ac3f2519d6 111 ts=getTimeStamp();
TickTock 85:5c27e88b3fbe 112 writeBuffer[writePointer][0]=mType;
TickTock 85:5c27e88b3fbe 113 writeBuffer[writePointer][1]=(ts&0xff00)>>8; // Time Stamp (2 bytes_
TickTock 85:5c27e88b3fbe 114 writeBuffer[writePointer][2]=(ts&0x00ff);
TickTock 85:5c27e88b3fbe 115 writeBuffer[writePointer][3]=canRXmsg.id&0xff; // MsgID, low byte
garygid 87:46ac3f2519d6 116 char sLen = canRXmsg.len ;
garygid 87:46ac3f2519d6 117 writeBuffer[writePointer][4]=(canRXmsg.id>>8)+(sLen<<4); // Len nibble, and MsgID high nibble
TickTock 89:2263d349b484 118 for(i=0;i<8;++i){ // Is there a better way to do this? (writeBuffer[writePointer][i]=canRXmsg.data?)
garygid 87:46ac3f2519d6 119 if(i<sLen)
garygid 87:46ac3f2519d6 120 writeBuffer[writePointer][i+5]=canRXmsg.data[i];
garygid 87:46ac3f2519d6 121 else // i>=sLen
garygid 87:46ac3f2519d6 122 // force unused data bytes to FF for CAN-Do compatibility
garygid 87:46ac3f2519d6 123 writeBuffer[writePointer][i+5]=0xFF;
TickTock 85:5c27e88b3fbe 124 }
garygid 87:46ac3f2519d6 125
TickTock 85:5c27e88b3fbe 126 //--------------
garygid 87:46ac3f2519d6 127 // Note, this is not protected from the interrupt.
garygid 87:46ac3f2519d6 128 // Due to the nLost code above, this no longer
TickTock 85:5c27e88b3fbe 129 // overflows to writePointer = readPointer
TickTock 85:5c27e88b3fbe 130 // which would make the buffer look empty
TickTock 85:5c27e88b3fbe 131 if (++writePointer >= maxBufLen) {
TickTock 85:5c27e88b3fbe 132 writePointer = 0;
TickTock 85:5c27e88b3fbe 133 led3 = !led3;
TickTock 85:5c27e88b3fbe 134 }
TickTock 85:5c27e88b3fbe 135 //--------------
TickTock 85:5c27e88b3fbe 136 // log a local message if we had lost messages. gg - logcan
TickTock 85:5c27e88b3fbe 137 if( nLost > 0 ) {
TickTock 85:5c27e88b3fbe 138 // We previously lost messages that did not get into the buffer
garygid 87:46ac3f2519d6 139 sprintf(sTemp,"-- Lost %d Messages.\n", nLost);
TickTock 88:45185a5f1c9b 140 printMsg(sTemp); // write buffer overrun
garygid 87:46ac3f2519d6 141 //spkr.beep(500,0.25);
TickTock 85:5c27e88b3fbe 142
TickTock 85:5c27e88b3fbe 143 nLost = 0 ;
TickTock 85:5c27e88b3fbe 144 }
TickTock 85:5c27e88b3fbe 145 //--------------
TickTock 85:5c27e88b3fbe 146 }
TickTock 83:52b1f330a62d 147 }
TickTock 85:5c27e88b3fbe 148 }
TickTock 88:45185a5f1c9b 149 } else { // not debugMode - keep code short
TickTock 85:5c27e88b3fbe 150 if(logOpen){
TickTock 88:45185a5f1c9b 151 int localWritePointer = writePointer++; // create local copy to make logCan reentrant
TickTock 88:45185a5f1c9b 152 // note that the static variables above do not prevent safe reentry
TickTock 88:45185a5f1c9b 153 // since they are only used for msgId<0x800 which will never interrupt
TickTock 88:45185a5f1c9b 154 // another msgId<0x800 (both CANbusses are same priority)
TickTock 88:45185a5f1c9b 155 if (writePointer >= maxBufLen) {
TickTock 88:45185a5f1c9b 156 writePointer = 0;
TickTock 88:45185a5f1c9b 157 led3 = !led3;
TickTock 88:45185a5f1c9b 158 }
TickTock 88:45185a5f1c9b 159 if (localWritePointer >= maxBufLen) { //Have to test local, too, just in case interrupted just after increment (got double incremented)
TickTock 88:45185a5f1c9b 160 localWritePointer = 0;
TickTock 88:45185a5f1c9b 161 }
TickTock 88:45185a5f1c9b 162 ts=getTimeStamp(); // only use
TickTock 88:45185a5f1c9b 163 writeBuffer[localWritePointer][0]=mType;
TickTock 88:45185a5f1c9b 164 writeBuffer[localWritePointer][1]=(ts&0xff00)>>8;
TickTock 88:45185a5f1c9b 165 writeBuffer[localWritePointer][2]=(ts&0x00ff);
TickTock 88:45185a5f1c9b 166 writeBuffer[localWritePointer][3]=canRXmsg.id&0xff;
TickTock 88:45185a5f1c9b 167 writeBuffer[localWritePointer][4]=(canRXmsg.id>>8)+(canRXmsg.len<<4);
TickTock 89:2263d349b484 168 for(i=5;i<13;++i){ // Is there a better way to do this? (writeBuffer[localWritePointer][i]=canRXmsg.data?)
TickTock 88:45185a5f1c9b 169 writeBuffer[localWritePointer][i]=canRXmsg.data[i-5];
TickTock 88:45185a5f1c9b 170 }
TickTock 88:45185a5f1c9b 171 if (writePointer==readPointer) {
TickTock 88:45185a5f1c9b 172 // Just caught up to read pointer
TickTock 88:45185a5f1c9b 173 sprintf(sTemp,"Write buffer overrun.\n");
TickTock 88:45185a5f1c9b 174 printMsg(sTemp); // write buffer overrun
TickTock 88:45185a5f1c9b 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 88:45185a5f1c9b 181
TickTock 83:52b1f330a62d 182 if(indexLastMsg[canRXmsg.id]==0) { //Check if no entry
garygid 87:46ac3f2519d6 183 if(ii<99) {
garygid 87:46ac3f2519d6 184 indexLastMsg[canRXmsg.id]=++ii; //Create entry for first MsgID occurance
garygid 87:46ac3f2519d6 185 // ii max is 99 here
garygid 87:46ac3f2519d6 186 } else {
garygid 87:46ac3f2519d6 187 // the ii array is full, more than 100 MsgIDs found
garygid 87:46ac3f2519d6 188 if(ii==99) {
TickTock 89:2263d349b484 189 ++ii; // step to 100 to log only one error
garygid 87:46ac3f2519d6 190 sprintf(sTemp,"MsgID buffer overrun.\n");
TickTock 88:45185a5f1c9b 191 printMsg(sTemp); // write buffer overrun
garygid 87:46ac3f2519d6 192 }
garygid 87:46ac3f2519d6 193 }
TickTock 83:52b1f330a62d 194 }
garygid 87:46ac3f2519d6 195
garygid 87:46ac3f2519d6 196 //----------------
TickTock 85:5c27e88b3fbe 197 if(dMode[0]==changedScreen||dMode[1]==changedScreen){// Skip if not using (for execution speed)
TickTock 83:52b1f330a62d 198 changed=msgChanged[indexLastMsg[canRXmsg.id]];
TickTock 85:5c27e88b3fbe 199 // This is cleared in the main loop when reset button is touched
TickTock 89:2263d349b484 200 for(i=0;i<8;++i){
TickTock 83:52b1f330a62d 201 if(lastMsg[indexLastMsg[canRXmsg.id]].data[i]!=canRXmsg.data[i]){
TickTock 83:52b1f330a62d 202 changed |= 1<<i;
garygid 80:24f1793171e7 203 }
TickTock 13:62e0f7f39ff5 204 }
TickTock 83:52b1f330a62d 205 msgChanged[indexLastMsg[canRXmsg.id]]=changed;
TickTock 13:62e0f7f39ff5 206 }
garygid 80:24f1793171e7 207
TickTock 83:52b1f330a62d 208 lastMsg[indexLastMsg[canRXmsg.id]]=canRXmsg; //Store in table
garygid 87:46ac3f2519d6 209
garygid 87:46ac3f2519d6 210 //-------------------
TickTock 83:52b1f330a62d 211 //Miscellaneous on-recieve operations below
TickTock 89:2263d349b484 212 if((mType==1)&&(canRXmsg.id==0x7bb)){ // is battery data? Need to store all responses
TickTock 83:52b1f330a62d 213 if(canRXmsg.data[0]<0x20){
garygid 87:46ac3f2519d6 214 if(canRXmsg.data[3]==2){//Group 2 = cellpair data
garygid 87:46ac3f2519d6 215 bdi=BatDataBaseG2; // index offset for CP data (uses 00 - 1C)
garygid 87:46ac3f2519d6 216 sprintf(sTemp," Getting cell pair data\n");
TickTock 88:45185a5f1c9b 217 printMsg(sTemp);
garygid 87:46ac3f2519d6 218
garygid 87:46ac3f2519d6 219 }else if(canRXmsg.data[3]==4){//Group 4 = temperature data
garygid 87:46ac3f2519d6 220 bdi=BatDataBaseG4; // index offset for Temperature data (uses 20 - 22)
garygid 87:46ac3f2519d6 221 sprintf(sTemp," Getting temperature data\n");
TickTock 88:45185a5f1c9b 222 printMsg(sTemp);
garygid 87:46ac3f2519d6 223
garygid 87:46ac3f2519d6 224 }else if(canRXmsg.data[3]==1){//Group 1 data
garygid 87:46ac3f2519d6 225 bdi=BatDataBaseG1; // index offset for Group 1 data (uses 20 - 22)
garygid 87:46ac3f2519d6 226 sprintf(sTemp,"Getting Group 1 data\n");
TickTock 88:45185a5f1c9b 227 printMsg(sTemp);
garygid 87:46ac3f2519d6 228
garygid 87:46ac3f2519d6 229 }else if(canRXmsg.data[3]==3){//Group 3 data
garygid 87:46ac3f2519d6 230 bdi=BatDataBaseG3; // index offset for Group 3 data (uses 20 - 22)
garygid 87:46ac3f2519d6 231 sprintf(sTemp," Getting Group 3 data\n");
TickTock 88:45185a5f1c9b 232 printMsg(sTemp);
garygid 87:46ac3f2519d6 233
garygid 87:46ac3f2519d6 234 }else if(canRXmsg.data[3]==5){//Group 5 data
garygid 87:46ac3f2519d6 235 bdi=BatDataBaseG5; // index offset for Group 5 data (uses 20 - 22)
garygid 87:46ac3f2519d6 236 sprintf(sTemp," Getting Group 5 data\n");
TickTock 88:45185a5f1c9b 237 printMsg(sTemp);
garygid 87:46ac3f2519d6 238
TickTock 83:52b1f330a62d 239 }else bdi=0xff; // ignore other messages (for now)
TickTock 83:52b1f330a62d 240 lasti=0;
TickTock 83:52b1f330a62d 241 }
garygid 87:46ac3f2519d6 242
TickTock 83:52b1f330a62d 243 if(bdi<0xff){
TickTock 83:52b1f330a62d 244 i=canRXmsg.data[0]&0x0f; //lower nibble of D0 is index
TickTock 83:52b1f330a62d 245 if(lasti>i){ //detect rollover and offset index appropriately
garygid 87:46ac3f2519d6 246 bdi=BatDataBaseG2 + 0x10; // only for CP data
TickTock 83:52b1f330a62d 247 }
TickTock 83:52b1f330a62d 248 lasti=i; //remember the msb to detect rollover next time around
TickTock 83:52b1f330a62d 249 i+=bdi;
garygid 87:46ac3f2519d6 250 //-------
garygid 87:46ac3f2519d6 251 if(i==BatDataBaseG4+2){ // Last of Temperature data
TickTock 83:52b1f330a62d 252 logCP=yesBattLog; // Only log if logging enabled
TickTock 83:52b1f330a62d 253 showCP=true; // Always show
TickTock 83:52b1f330a62d 254 }
garygid 87:46ac3f2519d6 255 //-------
TickTock 83:52b1f330a62d 256 i*=7;
garygid 87:46ac3f2519d6 257 //if(i<0xfa){ // Is there a better way to do this?
garygid 87:46ac3f2519d6 258 if(i+6 < BatDataBufMax) {
TickTock 83:52b1f330a62d 259 battData[i+0]=canRXmsg.data[1];
TickTock 83:52b1f330a62d 260 battData[i+1]=canRXmsg.data[2];
TickTock 83:52b1f330a62d 261 battData[i+2]=canRXmsg.data[3];
TickTock 83:52b1f330a62d 262 battData[i+3]=canRXmsg.data[4];
TickTock 83:52b1f330a62d 263 battData[i+4]=canRXmsg.data[5];
TickTock 83:52b1f330a62d 264 battData[i+5]=canRXmsg.data[6];
TickTock 83:52b1f330a62d 265 battData[i+6]=canRXmsg.data[7];
TickTock 83:52b1f330a62d 266 }
TickTock 83:52b1f330a62d 267 }
TickTock 83:52b1f330a62d 268 }else if((mType==1)&&(canRXmsg.id==0x1db)){ //Battery Volts and Amps
TickTock 83:52b1f330a62d 269 packV=((canRXmsg.data[2]<<2)|(canRXmsg.data[3]>>6)); // 1 LSB = 0.5V
TickTock 83:52b1f330a62d 270 packA=((canRXmsg.data[0]<<3)|(canRXmsg.data[1]>>5)); // 1 LSB = 0.5A
TickTock 83:52b1f330a62d 271 if(packA>0x03ff){
TickTock 83:52b1f330a62d 272 packA|=0xf800;//extend sign;
TickTock 83:52b1f330a62d 273 }
TickTock 83:52b1f330a62d 274 packA -= 1; //Slight correction to value required (unique to my Leaf?)
TickTock 83:52b1f330a62d 275 imWs_x4 = packV; // Volts*milliSeconds*2
TickTock 83:52b1f330a62d 276 imWs_x4 *= -packA; // milliWattseconds*4
TickTock 83:52b1f330a62d 277 if (!((imotorRPM<2)&&(imWs_x4<0))){ //Ignore if charging from wall
TickTock 83:52b1f330a62d 278 mWs_x4 += imWs_x4; // total mWs_x4
TickTock 89:2263d349b484 279 ++numWsamples;
TickTock 83:52b1f330a62d 280 }
TickTock 83:52b1f330a62d 281 }else if((mType==1)&&(canRXmsg.id==0x1da)){ //Motor Speed
TickTock 83:52b1f330a62d 282 imotorRPM=((canRXmsg.data[4]<<8)|(canRXmsg.data[5]));
TickTock 83:52b1f330a62d 283 if(imotorRPM<0){ // take absolute value
TickTock 83:52b1f330a62d 284 imotorRPM=-imotorRPM;
TickTock 83:52b1f330a62d 285 }
TickTock 83:52b1f330a62d 286 motorRPM+=imotorRPM;
TickTock 89:2263d349b484 287 ++numSsamples;
TickTock 37:fea2c1d52c5f 288 }
TickTock 37:fea2c1d52c5f 289 }
TickTock 13:62e0f7f39ff5 290 }
TickTock 13:62e0f7f39ff5 291
garygid 87:46ac3f2519d6 292 //-----------------------------
TickTock 13:62e0f7f39ff5 293 void logTS () {
TickTock 13:62e0f7f39ff5 294 CANMessage tsMsg;
TickTock 13:62e0f7f39ff5 295 unsigned long secs = time(NULL); // seconds past 12:00:00 AM 1 Jan 1900
garygid 69:6bfdfc002036 296 // NOTE: In Mbed, I believe that this is seconds past start of 1970, not 1900
garygid 69:6bfdfc002036 297 // but this is good, since seconds past 1970 is what CAN-Do expects. GG - Date Time
TickTock 13:62e0f7f39ff5 298 tsMsg.id=0xfff;
TickTock 13:62e0f7f39ff5 299 tsMsg.len=0xf;
garygid 69:6bfdfc002036 300 tsMsg.data[0]=secs&0xff;
TickTock 13:62e0f7f39ff5 301 tsMsg.data[1]=(secs>>8)&0xff;
TickTock 13:62e0f7f39ff5 302 tsMsg.data[2]=(secs>>16)&0xff;
garygid 69:6bfdfc002036 303 tsMsg.data[3]=(secs>>24)&0xff;
garygid 69:6bfdfc002036 304 tsMsg.data[4]=0; // 0xff; gg - Date Time
garygid 69:6bfdfc002036 305 tsMsg.data[5]=0; // 0xff; for CAN-Do
garygid 69:6bfdfc002036 306 tsMsg.data[6]=0; // 0xff;
TickTock 13:62e0f7f39ff5 307 tsMsg.data[7]=0xff;
garygid 69:6bfdfc002036 308 logCan(0,tsMsg); // Date-Time
garygid 69:6bfdfc002036 309 }
garygid 69:6bfdfc002036 310
TickTock 88:45185a5f1c9b 311 void logEventMsg (char * eventMsg) {
garygid 69:6bfdfc002036 312 // log CAN-Do 8-character Pseudo Message
garygid 69:6bfdfc002036 313 CANMessage tsMsg;
garygid 69:6bfdfc002036 314 tsMsg.id=0xffe; // pseudo Message to CAN-Do log
garygid 69:6bfdfc002036 315 tsMsg.len=0xf;
TickTock 88:45185a5f1c9b 316 int iMsgLen = strlen(eventMsg);
garygid 69:6bfdfc002036 317 // 8 character message compatible with CAN-Do
TickTock 89:2263d349b484 318 for(int i=0; i<8; ++i){
garygid 69:6bfdfc002036 319 tsMsg.data[i]=' ';
TickTock 88:45185a5f1c9b 320 if( i < iMsgLen ) tsMsg.data[i]=eventMsg[i];
garygid 69:6bfdfc002036 321 }
garygid 69:6bfdfc002036 322 logCan(0,tsMsg); // FFE Comment Message
TickTock 13:62e0f7f39ff5 323 }
TickTock 13:62e0f7f39ff5 324
TickTock 78:a383971fe02f 325 void sendReq() {
TickTock 78:a383971fe02f 326 static char data[8] = {0x02, 0x21, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff};
TickTock 78:a383971fe02f 327 if(reqMsgCnt<99){
TickTock 89:2263d349b484 328 switch (++reqMsgCnt){
TickTock 89:2263d349b484 329 case 1:
TickTock 78:a383971fe02f 330 can1.monitor(false); // set to active mode
TickTock 78:a383971fe02f 331 can1SleepMode = 0; // enable TX
TickTock 83:52b1f330a62d 332 data[0]=0x02; //change to request group 1
TickTock 78:a383971fe02f 333 data[1]=0x21;
TickTock 78:a383971fe02f 334 data[2]=0x01;
TickTock 78:a383971fe02f 335 break;
TickTock 89:2263d349b484 336 case 7: // group 1 has 6 frames
TickTock 78:a383971fe02f 337 can1.monitor(false); // set to active mode
TickTock 78:a383971fe02f 338 can1SleepMode = 0; // enable TX
TickTock 83:52b1f330a62d 339 data[0]=0x02; //change to request group 2 (cp data)
TickTock 78:a383971fe02f 340 data[1]=0x21;
TickTock 78:a383971fe02f 341 data[2]=0x02;
TickTock 78:a383971fe02f 342 break;
TickTock 89:2263d349b484 343 case 36: // group 2 has 29 frames
TickTock 83:52b1f330a62d 344 data[0]=0x02; //change to request group 3
TickTock 78:a383971fe02f 345 data[1]=0x21;
TickTock 78:a383971fe02f 346 data[2]=0x03;
TickTock 78:a383971fe02f 347 break;
TickTock 89:2263d349b484 348 case 41: // group 3 has 5 frames
TickTock 83:52b1f330a62d 349 data[0]=0x02; //change to request group 4 (temperature)
TickTock 78:a383971fe02f 350 data[1]=0x21;
TickTock 78:a383971fe02f 351 data[2]=0x04;
TickTock 78:a383971fe02f 352 break;
TickTock 89:2263d349b484 353 case 44: // group 4 has 3 frames
TickTock 83:52b1f330a62d 354 data[0]=0x02; //change to request group 5
TickTock 78:a383971fe02f 355 data[1]=0x21;
TickTock 78:a383971fe02f 356 data[2]=0x05;
TickTock 78:a383971fe02f 357 break;
TickTock 89:2263d349b484 358 case 55: // group 5 has 11 frames
TickTock 78:a383971fe02f 359 reqMsgCnt = 99;
TickTock 78:a383971fe02f 360 can1SleepMode = 1; // disable TX
TickTock 78:a383971fe02f 361 can1.monitor(true); // set to snoop mode
TickTock 83:52b1f330a62d 362 msgReq.detach(); // stop ticker
TickTock 78:a383971fe02f 363 default:
TickTock 78:a383971fe02f 364 data[0]=0x30; //change to request next line message
TickTock 78:a383971fe02f 365 data[1]=0x01;
TickTock 78:a383971fe02f 366 data[2]=0x00;
TickTock 78:a383971fe02f 367 }
TickTock 78:a383971fe02f 368 can1.write(CANMessage(0x79b, data, 8));
TickTock 78:a383971fe02f 369 }
TickTock 78:a383971fe02f 370 }
TickTock 78:a383971fe02f 371
TickTock 78:a383971fe02f 372 void autoPollISR(){
TickTock 78:a383971fe02f 373 reqMsgCnt = 0; //reset message counter
garygid 87:46ac3f2519d6 374 msgReq.attach(&sendReq,0.025);
TickTock 78:a383971fe02f 375 }
garygid 87:46ac3f2519d6 376
TickTock 36:dbd39c315258 377 void playbackISR() { //Used for autoplayback
TickTock 36:dbd39c315258 378 step=true;
TickTock 36:dbd39c315258 379 }
TickTock 36:dbd39c315258 380
TickTock 36:dbd39c315258 381 void doNothing(){ //CAN deattach work-around
TickTock 36:dbd39c315258 382 }
TickTock 36:dbd39c315258 383
TickTock 13:62e0f7f39ff5 384 void recieve1() {
TickTock 13:62e0f7f39ff5 385 CANMessage msg1;
TickTock 13:62e0f7f39ff5 386 can1.read(msg1);
garygid 69:6bfdfc002036 387
garygid 69:6bfdfc002036 388 if( ZeroSecTick ) { ZeroSecTick = false; logTS(); } // gg - 0-second EV bus
garygid 69:6bfdfc002036 389
garygid 69:6bfdfc002036 390 logCan(1, msg1); // EVcan Message Received
TickTock 13:62e0f7f39ff5 391 led1 = !led1;
TickTock 13:62e0f7f39ff5 392 }
TickTock 13:62e0f7f39ff5 393
TickTock 13:62e0f7f39ff5 394 void recieve2() {
TickTock 13:62e0f7f39ff5 395 CANMessage msg2;
TickTock 13:62e0f7f39ff5 396 can2.read(msg2);
garygid 69:6bfdfc002036 397
garygid 69:6bfdfc002036 398 if( ZeroSecTick ) { ZeroSecTick = false; logTS(); } // gg - 0-second EV bus
garygid 69:6bfdfc002036 399
garygid 69:6bfdfc002036 400 logCan(2, msg2); // CARcan Message Received
TickTock 13:62e0f7f39ff5 401 led2 = !led2;
TickTock 13:62e0f7f39ff5 402 }
TickTock 13:62e0f7f39ff5 403
TickTock 22:a43df3905863 404 unsigned char buttonX(unsigned short X, unsigned char columns) {
TickTock 22:a43df3905863 405 unsigned char val = X*columns/320;
TickTock 22:a43df3905863 406 return val;
TickTock 22:a43df3905863 407 }
TickTock 22:a43df3905863 408
TickTock 22:a43df3905863 409 unsigned char buttonY(unsigned short Y, unsigned char rows) {
TickTock 22:a43df3905863 410 unsigned short val = Y*rows/240;
TickTock 22:a43df3905863 411 return val;
TickTock 22:a43df3905863 412 }
TickTock 23:cd03f9c3395e 413
TickTock 23:cd03f9c3395e 414 void saveConfig(){
TickTock 23:cd03f9c3395e 415 FILE *cfile;
TickTock 23:cd03f9c3395e 416 cfile = fopen("/local/config.txt", "w");
garygid 87:46ac3f2519d6 417 //fprintf(cfile,"format 3\r\n");
garygid 87:46ac3f2519d6 418 fprintf(cfile,"format 4\r\n");
TickTock 23:cd03f9c3395e 419 fprintf(cfile,"x0_off %d\r\n",tt.x0_off);
TickTock 23:cd03f9c3395e 420 fprintf(cfile,"y0_off %d\r\n",tt.y0_off);
TickTock 23:cd03f9c3395e 421 fprintf(cfile,"x0_pp %d\r\n",tt.x0_pp);
TickTock 23:cd03f9c3395e 422 fprintf(cfile,"y0_pp %d\r\n",tt.y0_pp);
TickTock 23:cd03f9c3395e 423 fprintf(cfile,"x1_off %d\r\n",tt.x1_off);
TickTock 23:cd03f9c3395e 424 fprintf(cfile,"y1_off %d\r\n",tt.y1_off);
TickTock 23:cd03f9c3395e 425 fprintf(cfile,"x1_pp %d\r\n",tt.x1_pp);
TickTock 23:cd03f9c3395e 426 fprintf(cfile,"y1_pp %d\r\n",tt.y1_pp);
TickTock 23:cd03f9c3395e 427 fprintf(cfile,"x_mid %d\r\n",tt.x_mid);
TickTock 26:462ccb580472 428 if (dMode[0]==config1Screen)
TickTock 41:8d4609ea7259 429 fprintf(cfile,"dMode0 %d\r\n",mainScreen);
TickTock 26:462ccb580472 430 else
TickTock 26:462ccb580472 431 fprintf(cfile,"dMode0 %d\r\n",dMode[0]);
TickTock 26:462ccb580472 432 if (dMode[1]==config1Screen)
TickTock 41:8d4609ea7259 433 fprintf(cfile,"dMode1 %d\r\n",mainScreen);
TickTock 26:462ccb580472 434 else
TickTock 26:462ccb580472 435 fprintf(cfile,"dMode1 %d\r\n",dMode[1]);
TickTock 35:5acbd8a64a89 436 fprintf(cfile,"ledHi %4.3f\r\n",ledHi);
TickTock 35:5acbd8a64a89 437 fprintf(cfile,"ledLo %4.3f\r\n",ledLo);
TickTock 35:5acbd8a64a89 438 fprintf(cfile,"pollInt %d\r\n",pollInt);
TickTock 35:5acbd8a64a89 439 fprintf(cfile,"scale12V %4.2f\r\n",scale12V);
TickTock 48:d1ce92104a1f 440 fprintf(cfile,"skin %d\r\n",skin);
TickTock 50:83d5864c64a0 441 fprintf(cfile,"dtePeriod %d\r\n",dtePeriod);
garygid 87:46ac3f2519d6 442 fprintf(cfile,"DebugMode %d\r\n",(debugMode?1:0));
TickTock 23:cd03f9c3395e 443 fclose(cfile);
TickTock 23:cd03f9c3395e 444 }
TickTock 23:cd03f9c3395e 445
TickTock 23:cd03f9c3395e 446 void readConfig(){
TickTock 23:cd03f9c3395e 447 FILE *cfile;
TickTock 23:cd03f9c3395e 448 int ff;
TickTock 23:cd03f9c3395e 449 char sTemp[40];
TickTock 23:cd03f9c3395e 450 cfile = fopen("/local/config.txt", "r");
TickTock 23:cd03f9c3395e 451 if (cfile==NULL){ // if doesn't exist --> create
TickTock 23:cd03f9c3395e 452 sprintf(sTemp,"No config file found.\n");
TickTock 88:45185a5f1c9b 453 printMsg(sTemp); // no config file
TickTock 23:cd03f9c3395e 454 sprintf(sTemp,"Calibrating touch screen.\n");
TickTock 88:45185a5f1c9b 455 printMsg(sTemp); // calibrating
TickTock 23:cd03f9c3395e 456 //tt.setcal(5570, 34030, 80, 108, 33700, 5780, 82, 108, 32500);// bypass calibration using my values
TickTock 23:cd03f9c3395e 457 tt.calibrate(); // run touchscreen calibration routine
garygid 58:4d06288d75a2 458 // NOTE: calibrates screen 1 first, then screen 0.
TickTock 23:cd03f9c3395e 459 saveConfig();
TickTock 23:cd03f9c3395e 460 } else {
TickTock 48:d1ce92104a1f 461 ledHi = 0.823;
TickTock 48:d1ce92104a1f 462 ledLo = 0.1;
TickTock 48:d1ce92104a1f 463 pollInt = 300;
TickTock 48:d1ce92104a1f 464 scale12V = 16.2;
TickTock 48:d1ce92104a1f 465 skin = ttSkin;
TickTock 48:d1ce92104a1f 466 fscanf(cfile, "format %d\r\n", &ff ) ;
TickTock 23:cd03f9c3395e 467 fscanf(cfile, "x0_off %d\r\n", &tt.x0_off ) ;
TickTock 23:cd03f9c3395e 468 fscanf(cfile, "y0_off %d\r\n", &tt.y0_off ) ;
TickTock 23:cd03f9c3395e 469 fscanf(cfile, "x0_pp %d\r\n", &tt.x0_pp ) ;
TickTock 23:cd03f9c3395e 470 fscanf(cfile, "y0_pp %d\r\n", &tt.y0_pp ) ;
TickTock 23:cd03f9c3395e 471 fscanf(cfile, "x1_off %d\r\n", &tt.x1_off ) ;
TickTock 23:cd03f9c3395e 472 fscanf(cfile, "y1_off %d\r\n", &tt.y1_off ) ;
TickTock 23:cd03f9c3395e 473 fscanf(cfile, "x1_pp %d\r\n", &tt.x1_pp ) ;
TickTock 23:cd03f9c3395e 474 fscanf(cfile, "y1_pp %d\r\n", &tt.y1_pp ) ;
TickTock 23:cd03f9c3395e 475 fscanf(cfile, "x_mid %d\r\n", &tt.x_mid ) ;
TickTock 26:462ccb580472 476 fscanf(cfile, "dMode0 %d\r\n", &dMode[0] ) ;
TickTock 26:462ccb580472 477 fscanf(cfile, "dMode1 %d\r\n", &dMode[1] ) ;
TickTock 35:5acbd8a64a89 478 if(ff>1){
TickTock 48:d1ce92104a1f 479 fscanf(cfile, "ledHi %f\r\n", &ledHi ) ;
TickTock 48:d1ce92104a1f 480 fscanf(cfile, "ledLo %f\r\n", &ledLo ) ;
TickTock 35:5acbd8a64a89 481 fscanf(cfile, "pollInt %d\r\n", &pollInt ) ;
TickTock 48:d1ce92104a1f 482 fscanf(cfile, "scale12V %f\r\n", &scale12V ) ;
TickTock 48:d1ce92104a1f 483 }
TickTock 48:d1ce92104a1f 484 if(ff>2){
TickTock 48:d1ce92104a1f 485 fscanf(cfile, "skin %d\r\n", &skin ) ;
TickTock 50:83d5864c64a0 486 fscanf(cfile, "dtePeriod %d\r\n", &dtePeriod ) ;
TickTock 35:5acbd8a64a89 487 }
garygid 87:46ac3f2519d6 488 if(ff>3){
garygid 87:46ac3f2519d6 489 int iDebug ;
garygid 87:46ac3f2519d6 490 fscanf(cfile, "DebugMode %d\r\n", &iDebug ) ;
garygid 87:46ac3f2519d6 491 debugMode = (iDebug==1)?true:false ;
garygid 87:46ac3f2519d6 492 }
TickTock 23:cd03f9c3395e 493 fclose(cfile);
garygid 87:46ac3f2519d6 494
garygid 87:46ac3f2519d6 495 //if(ff<3){//If not latest format, save as latest format
garygid 87:46ac3f2519d6 496 if(ff<4){//If not latest format, save as latest format
TickTock 35:5acbd8a64a89 497 saveConfig();
TickTock 48:d1ce92104a1f 498 sprintf(sTemp,"Config file format updated.\n");
TickTock 88:45185a5f1c9b 499 printMsg(sTemp); // config forat updates
TickTock 48:d1ce92104a1f 500 }
TickTock 43:e7f6f80590e3 501 sprintf(sTemp,"Config file loaded.\n");
TickTock 88:45185a5f1c9b 502 printMsg(sTemp); // config file loaded
TickTock 23:cd03f9c3395e 503 }
TickTock 23:cd03f9c3395e 504 }
TickTock 25:ddf0ec209f03 505
TickTock 25:ddf0ec209f03 506 void upDate(unsigned char field, bool upDownBar){
TickTock 25:ddf0ec209f03 507 struct tm t; // pointer to a static tm structure
TickTock 25:ddf0ec209f03 508 time_t seconds ;
TickTock 25:ddf0ec209f03 509 seconds = time(NULL);
TickTock 25:ddf0ec209f03 510 t = *localtime(&seconds) ;
TickTock 25:ddf0ec209f03 511 switch(field){
TickTock 25:ddf0ec209f03 512 case 0: // year
TickTock 25:ddf0ec209f03 513 if (upDownBar) {
TickTock 25:ddf0ec209f03 514 t.tm_year = t.tm_year+1;
TickTock 25:ddf0ec209f03 515 } else {
TickTock 25:ddf0ec209f03 516 t.tm_year = t.tm_year-1;
TickTock 25:ddf0ec209f03 517 }
TickTock 25:ddf0ec209f03 518 break;
TickTock 25:ddf0ec209f03 519 case 1: // month
TickTock 25:ddf0ec209f03 520 if (upDownBar) {
TickTock 25:ddf0ec209f03 521 t.tm_mon = (t.tm_mon<12)?t.tm_mon+1:1;
TickTock 25:ddf0ec209f03 522 } else {
TickTock 25:ddf0ec209f03 523 t.tm_mon = (t.tm_mon>2)?t.tm_mon-1:12;
TickTock 25:ddf0ec209f03 524 }
TickTock 25:ddf0ec209f03 525 break;
TickTock 25:ddf0ec209f03 526 case 2: // day
TickTock 25:ddf0ec209f03 527 if (upDownBar) {
TickTock 25:ddf0ec209f03 528 t.tm_mday = (t.tm_mday<31)?t.tm_mday+1:1;
TickTock 25:ddf0ec209f03 529 } else {
TickTock 25:ddf0ec209f03 530 t.tm_mday = (t.tm_mday>2)?t.tm_mday-1:31;
TickTock 25:ddf0ec209f03 531 }
TickTock 25:ddf0ec209f03 532 break;
TickTock 25:ddf0ec209f03 533 case 3: // hour
TickTock 25:ddf0ec209f03 534 if (upDownBar) {
TickTock 25:ddf0ec209f03 535 t.tm_hour = (t.tm_hour<23)?t.tm_hour+1:0;
TickTock 25:ddf0ec209f03 536 } else {
TickTock 25:ddf0ec209f03 537 t.tm_hour = (t.tm_hour>1)?t.tm_hour-1:23;
TickTock 25:ddf0ec209f03 538 }
TickTock 25:ddf0ec209f03 539 break;
TickTock 25:ddf0ec209f03 540 case 4: // minute
TickTock 25:ddf0ec209f03 541 if (upDownBar) {
TickTock 25:ddf0ec209f03 542 t.tm_min = (t.tm_min<59)?t.tm_min+1:0;
TickTock 25:ddf0ec209f03 543 } else {
TickTock 25:ddf0ec209f03 544 t.tm_min = (t.tm_min>1)?t.tm_min-1:59;
TickTock 25:ddf0ec209f03 545 }
TickTock 25:ddf0ec209f03 546 break;
TickTock 25:ddf0ec209f03 547 case 5: // second
TickTock 25:ddf0ec209f03 548 if (upDownBar) {
TickTock 25:ddf0ec209f03 549 t.tm_sec = (t.tm_sec<59)?t.tm_sec+1:0;
TickTock 25:ddf0ec209f03 550 } else {
TickTock 25:ddf0ec209f03 551 t.tm_sec = (t.tm_sec>1)?t.tm_sec-1:59;
TickTock 25:ddf0ec209f03 552 }
TickTock 25:ddf0ec209f03 553 break;
TickTock 25:ddf0ec209f03 554 default:
TickTock 25:ddf0ec209f03 555 break;
TickTock 25:ddf0ec209f03 556 }
TickTock 25:ddf0ec209f03 557 set_time(mktime(&t));
TickTock 25:ddf0ec209f03 558 }
TickTock 25:ddf0ec209f03 559
TickTock 39:eef8beac7411 560 void logPackVoltages() { // Turbo3 - routine to dump CP values to text file
TickTock 39:eef8beac7411 561 char sTemp[40];
TickTock 39:eef8beac7411 562 struct tm t; // pointer to a static tm structure
TickTock 39:eef8beac7411 563 short unsigned max, min, jv, i, bd;
TickTock 39:eef8beac7411 564 unsigned avg;
TickTock 39:eef8beac7411 565 unsigned short gids, SOC, packV;
TickTock 39:eef8beac7411 566 signed short packA;
TickTock 39:eef8beac7411 567 time_t seconds ;
TickTock 39:eef8beac7411 568
TickTock 39:eef8beac7411 569 CANMessage msg;
TickTock 39:eef8beac7411 570
TickTock 39:eef8beac7411 571 seconds = time(NULL); // Turbo3
TickTock 39:eef8beac7411 572 t = *localtime(&seconds) ; // Turbo3
TickTock 39:eef8beac7411 573
TickTock 39:eef8beac7411 574 msg = lastMsg[indexLastMsg[0x5bc]]; //Get gids
TickTock 39:eef8beac7411 575 gids = (msg.data[0]<<2)+(msg.data[1]>>6);
TickTock 39:eef8beac7411 576 msg = lastMsg[indexLastMsg[0x55b]]; //Get SOC
TickTock 39:eef8beac7411 577 SOC = (msg.data[0]<<2)+(msg.data[1]>>6);
TickTock 39:eef8beac7411 578 msg = lastMsg[indexLastMsg[0x1db]]; //Get pack volts
TickTock 39:eef8beac7411 579 packV = (msg.data[2]<<2)+(msg.data[3]>>6);
TickTock 39:eef8beac7411 580 packA = (msg.data[0]<<3)+(msg.data[1]>>5);
TickTock 39:eef8beac7411 581 if (packA & 0x400) packA |= 0xf800;
TickTock 39:eef8beac7411 582
TickTock 39:eef8beac7411 583 max=0;
TickTock 39:eef8beac7411 584 min=9999;
TickTock 39:eef8beac7411 585 avg=0;
TickTock 89:2263d349b484 586 for(i=0; i<96; ++i) {
TickTock 39:eef8beac7411 587 bd=(battData[i*2+3]<<8)+battData[i*2+4];
TickTock 39:eef8beac7411 588 avg+=bd;
TickTock 39:eef8beac7411 589 if(bd>max) max=bd;
TickTock 39:eef8beac7411 590 if(bd<min) min=bd;
TickTock 39:eef8beac7411 591 }
TickTock 39:eef8beac7411 592 avg /= 96;
TickTock 39:eef8beac7411 593 if(min<3713) {
TickTock 39:eef8beac7411 594 jv=avg-(max-avg)*1.5;
TickTock 39:eef8beac7411 595 } else { // Only compute judgement value if min cellpair meets <= 3712mV requirement
TickTock 39:eef8beac7411 596 jv=0;
TickTock 39:eef8beac7411 597 }
TickTock 39:eef8beac7411 598
TickTock 39:eef8beac7411 599 FILE *bfile;
TickTock 39:eef8beac7411 600 //bfile = fopen("/local/batvolt.txt", "a");
TickTock 39:eef8beac7411 601 bfile = fopen("/usb/batvolt.txt", "a");
TickTock 39:eef8beac7411 602 if(bfile!=NULL) {
TickTock 39:eef8beac7411 603 strftime(sTemp, 40, "%a %m/%d/%Y %X", &t);
TickTock 39:eef8beac7411 604 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);
garygid 87:46ac3f2519d6 605 // BatDataBaseG4 * 7 = 224
TickTock 39:eef8beac7411 606 fprintf(bfile,"%d,%d,%d,%d,",(battData[224+ 3]<<8)+battData[224+ 4],battData[224+ 5],(battData[224+ 6]<<8)+battData[224+ 7],battData[224+ 8]);
TickTock 39:eef8beac7411 607 fprintf(bfile,"%d,%d,%d,%d", (battData[224+ 9]<<8)+battData[224+10],battData[224+11],(battData[224+12]<<8)+battData[224+13],battData[224+14]);
TickTock 89:2263d349b484 608 for(i=0; i<96; ++i) {
TickTock 39:eef8beac7411 609 bd=(battData[i*2+3]<<8)+battData[i*2+4];
TickTock 39:eef8beac7411 610 fprintf(bfile,",%d",bd);
TickTock 39:eef8beac7411 611 }
TickTock 39:eef8beac7411 612 fprintf(bfile,"\r\n");
TickTock 39:eef8beac7411 613 fclose(bfile);
TickTock 39:eef8beac7411 614 }
TickTock 39:eef8beac7411 615 logCP=false;
TickTock 40:0e6e71a7323f 616 showCP=true;
TickTock 39:eef8beac7411 617 }
TickTock 25:ddf0ec209f03 618