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@79:68f0dd8d1f19, 2013-04-16 (annotated)

Committer:
TickTock
Date:
Tue Apr 16 22:31:47 2013 +0000
Revision:
79:68f0dd8d1f19
Parent:
78:a383971fe02f
Child:
126:e0d039096891
Just turn on the message-send ticker when actually sending (instead of continuously triggering).

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 13:62e0f7f39ff5 24 void logMsg (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) {
garygid 69:6bfdfc002036 42 char sTemp[40];
TickTock 13:62e0f7f39ff5 43 unsigned short ts = getTimeStamp();
TickTock 13:62e0f7f39ff5 44 static unsigned char ii = 0, lasti = 0; // indexindex
TickTock 13:62e0f7f39ff5 45 unsigned char changed,i;
TickTock 37:fea2c1d52c5f 46 static unsigned char bdi=0;
TickTock 40:0e6e71a7323f 47 signed short packV;
TickTock 37:fea2c1d52c5f 48 signed short packA;
TickTock 41:8d4609ea7259 49 static signed short imotorRPM = 0;
TickTock 40:0e6e71a7323f 50 signed long imWs_x4;
garygid 69:6bfdfc002036 51
TickTock 36:dbd39c315258 52 secsNoMsg=0; // reset deadman switch
TickTock 13:62e0f7f39ff5 53 if(logOpen){
TickTock 13:62e0f7f39ff5 54 if(canRXmsg.id>0) {
TickTock 13:62e0f7f39ff5 55 writeBuffer[writePointer][0]=mType;
TickTock 37:fea2c1d52c5f 56 writeBuffer[writePointer][1]=(ts&0xff00)>>8;
TickTock 37:fea2c1d52c5f 57 writeBuffer[writePointer][2]=(ts&0x00ff);
TickTock 13:62e0f7f39ff5 58 writeBuffer[writePointer][3]=canRXmsg.id&0xff;
TickTock 13:62e0f7f39ff5 59 writeBuffer[writePointer][4]=(canRXmsg.id>>8)+(canRXmsg.len<<4);
TickTock 40:0e6e71a7323f 60 for(i=5;i<13;i++){ // Is there a better way to do this? (writeBuffer[writePointer][i]=canRXmsg.data?)
TickTock 13:62e0f7f39ff5 61 writeBuffer[writePointer][i]=canRXmsg.data[i-5];
TickTock 13:62e0f7f39ff5 62 }
TickTock 77:7c136766466c 63 if (++writePointer >= maxBufLen) {
TickTock 77:7c136766466c 64 writePointer = 0;
TickTock 77:7c136766466c 65 led3 = !led3;
TickTock 77:7c136766466c 66 }
TickTock 75:77bd26829dca 67 if (writePointer==readPointer) {
TickTock 75:77bd26829dca 68 // Just overwrote an entry that hasn't been sent to thumbdrive
TickTock 75:77bd26829dca 69 sprintf(sTemp,"Write buffer overrun.\n");
TickTock 75:77bd26829dca 70 logMsg(sTemp); // write buffer overrun
TickTock 77:7c136766466c 71 spkr.beep(500,0.25);
TickTock 13:62e0f7f39ff5 72 }
TickTock 13:62e0f7f39ff5 73 }
TickTock 37:fea2c1d52c5f 74 }
TickTock 40:0e6e71a7323f 75
TickTock 13:62e0f7f39ff5 76 if(indexLastMsg[canRXmsg.id]==0) { //Check if no entry
TickTock 13:62e0f7f39ff5 77 ii=ii<99?ii+1:0;
TickTock 13:62e0f7f39ff5 78 indexLastMsg[canRXmsg.id]=ii; //Create entry if first message
TickTock 13:62e0f7f39ff5 79 }
TickTock 13:62e0f7f39ff5 80 if(dMode[0]==changedScreen||dMode[1]==changedScreen){
TickTock 13:62e0f7f39ff5 81 changed=msgChanged[indexLastMsg[canRXmsg.id]];
TickTock 13:62e0f7f39ff5 82 for(i=0;i<8;i++){
TickTock 13:62e0f7f39ff5 83 if(lastMsg[indexLastMsg[canRXmsg.id]].data[i]!=canRXmsg.data[i]){
TickTock 13:62e0f7f39ff5 84 changed |= 1<<i;
TickTock 13:62e0f7f39ff5 85 }
TickTock 13:62e0f7f39ff5 86 }
TickTock 13:62e0f7f39ff5 87 msgChanged[indexLastMsg[canRXmsg.id]]=changed;
TickTock 13:62e0f7f39ff5 88 }
TickTock 41:8d4609ea7259 89
TickTock 13:62e0f7f39ff5 90 lastMsg[indexLastMsg[canRXmsg.id]]=canRXmsg; //Store in table
TickTock 41:8d4609ea7259 91
TickTock 41:8d4609ea7259 92 //Miscellaneous on-recieve operations below
TickTock 34:4751a8259b18 93 if((mType==2)&&(canRXmsg.id==0x358)){ // headlight/turn signal indicator
TickTock 34:4751a8259b18 94 headlights = (canRXmsg.data[1]&0x80)?true:false;
TickTock 37:fea2c1d52c5f 95 }else if((mType==1)&&(canRXmsg.id==0x7bb)){ // is battery data? Need to store all responses
TickTock 13:62e0f7f39ff5 96 if(canRXmsg.data[0]<0x20){
TickTock 13:62e0f7f39ff5 97 if(canRXmsg.data[3]==2){//cellpair data
TickTock 13:62e0f7f39ff5 98 bdi=0;
TickTock 13:62e0f7f39ff5 99 sprintf(sTemp,"Getting cell pair data\n");
TickTock 13:62e0f7f39ff5 100 logMsg(sTemp);
TickTock 37:fea2c1d52c5f 101 }else if(canRXmsg.data[3]==4){//temperature data
TickTock 13:62e0f7f39ff5 102 bdi=0x20;
TickTock 13:62e0f7f39ff5 103 sprintf(sTemp,"Getting temperature data\n");
TickTock 13:62e0f7f39ff5 104 logMsg(sTemp);
TickTock 78:a383971fe02f 105 }else bdi=0xff; // ignore other messages (for now)
TickTock 13:62e0f7f39ff5 106 lasti=0;
TickTock 13:62e0f7f39ff5 107 }
TickTock 78:a383971fe02f 108 if(bdi<0xff){
TickTock 78:a383971fe02f 109 i=canRXmsg.data[0]&0x0f; //lower nibble of D0 is index
TickTock 78:a383971fe02f 110 if(lasti>i){ //detect rollover and offset index appropriately
TickTock 78:a383971fe02f 111 bdi=0x10;
TickTock 78:a383971fe02f 112 }
TickTock 78:a383971fe02f 113 lasti=i; //remember the msb to detect rollover next time around
TickTock 78:a383971fe02f 114 i+=bdi;
TickTock 78:a383971fe02f 115 //if(i==22) logCP=true; //Turbo3
TickTock 78:a383971fe02f 116 //if( (i==22) && (yesBattLog) ) logCP=true; // only if enabled gg - Batt Log
TickTock 78:a383971fe02f 117 if(i==22){
TickTock 78:a383971fe02f 118 logCP=yesBattLog; // Only log if logging enabled
TickTock 78:a383971fe02f 119 showCP=true; // Always show
TickTock 78:a383971fe02f 120 }
TickTock 78:a383971fe02f 121 i*=7;
TickTock 78:a383971fe02f 122 if(i<0xfa){ // Is there a better way to do this?
TickTock 78:a383971fe02f 123 battData[i+0]=canRXmsg.data[1];
TickTock 78:a383971fe02f 124 battData[i+1]=canRXmsg.data[2];
TickTock 78:a383971fe02f 125 battData[i+2]=canRXmsg.data[3];
TickTock 78:a383971fe02f 126 battData[i+3]=canRXmsg.data[4];
TickTock 78:a383971fe02f 127 battData[i+4]=canRXmsg.data[5];
TickTock 78:a383971fe02f 128 battData[i+5]=canRXmsg.data[6];
TickTock 78:a383971fe02f 129 battData[i+6]=canRXmsg.data[7];
TickTock 78:a383971fe02f 130 }
TickTock 13:62e0f7f39ff5 131 }
TickTock 37:fea2c1d52c5f 132 }else if((mType==1)&&(canRXmsg.id==0x1db)){ //Battery Volts and Amps
TickTock 37:fea2c1d52c5f 133 packV=((canRXmsg.data[2]<<2)|(canRXmsg.data[3]>>6)); // 1 LSB = 0.5V
TickTock 37:fea2c1d52c5f 134 packA=((canRXmsg.data[0]<<3)|(canRXmsg.data[1]>>5)); // 1 LSB = 0.5A
TickTock 37:fea2c1d52c5f 135 if(packA>0x03ff){
TickTock 37:fea2c1d52c5f 136 packA|=0xf800;//extend sign;
TickTock 37:fea2c1d52c5f 137 }
TickTock 79:68f0dd8d1f19 138 packA -= 1; //Slight correction to value required (unique to my Leaf?)
TickTock 40:0e6e71a7323f 139 imWs_x4 = packV; // Volts*milliSeconds*2
TickTock 40:0e6e71a7323f 140 imWs_x4 *= -packA; // milliWattseconds*4
TickTock 41:8d4609ea7259 141 if (!((imotorRPM<2)&&(imWs_x4<0))){ //Ignore if charging from wall
TickTock 41:8d4609ea7259 142 mWs_x4 += imWs_x4; // total mWs_x4
TickTock 41:8d4609ea7259 143 numWsamples++;
TickTock 41:8d4609ea7259 144 }
TickTock 41:8d4609ea7259 145 }else if((mType==1)&&(canRXmsg.id==0x1da)){ //Motor Speed
TickTock 41:8d4609ea7259 146 imotorRPM=((canRXmsg.data[4]<<8)|(canRXmsg.data[5]));
TickTock 51:6187c5264a73 147 if(imotorRPM<0){ // take absolute value
TickTock 51:6187c5264a73 148 imotorRPM=-imotorRPM;
TickTock 51:6187c5264a73 149 }
TickTock 41:8d4609ea7259 150 motorRPM+=imotorRPM;
TickTock 41:8d4609ea7259 151 numSsamples++;
TickTock 37:fea2c1d52c5f 152 }
TickTock 13:62e0f7f39ff5 153 }
TickTock 13:62e0f7f39ff5 154
TickTock 13:62e0f7f39ff5 155 void logTS () {
TickTock 13:62e0f7f39ff5 156 CANMessage tsMsg;
TickTock 13:62e0f7f39ff5 157 unsigned long secs = time(NULL); // seconds past 12:00:00 AM 1 Jan 1900
garygid 69:6bfdfc002036 158 // NOTE: In Mbed, I believe that this is seconds past start of 1970, not 1900
garygid 69:6bfdfc002036 159 // but this is good, since seconds past 1970 is what CAN-Do expects. GG - Date Time
TickTock 13:62e0f7f39ff5 160 tsMsg.id=0xfff;
TickTock 13:62e0f7f39ff5 161 tsMsg.len=0xf;
garygid 69:6bfdfc002036 162 tsMsg.data[0]=secs&0xff;
TickTock 13:62e0f7f39ff5 163 tsMsg.data[1]=(secs>>8)&0xff;
TickTock 13:62e0f7f39ff5 164 tsMsg.data[2]=(secs>>16)&0xff;
garygid 69:6bfdfc002036 165 tsMsg.data[3]=(secs>>24)&0xff;
garygid 69:6bfdfc002036 166 tsMsg.data[4]=0; // 0xff; gg - Date Time
garygid 69:6bfdfc002036 167 tsMsg.data[5]=0; // 0xff; for CAN-Do
garygid 69:6bfdfc002036 168 tsMsg.data[6]=0; // 0xff;
TickTock 13:62e0f7f39ff5 169 tsMsg.data[7]=0xff;
garygid 69:6bfdfc002036 170 logCan(0,tsMsg); // Date-Time
garygid 69:6bfdfc002036 171 }
garygid 69:6bfdfc002036 172
garygid 69:6bfdfc002036 173 void logErrMsg (char * errMsg) {
garygid 69:6bfdfc002036 174 // log CAN-Do 8-character Pseudo Message
garygid 69:6bfdfc002036 175 CANMessage tsMsg;
garygid 69:6bfdfc002036 176 tsMsg.id=0xffe; // pseudo Message to CAN-Do log
garygid 69:6bfdfc002036 177 tsMsg.len=0xf;
garygid 69:6bfdfc002036 178 int iMsgLen = strlen(errMsg);
garygid 69:6bfdfc002036 179 // 8 character message compatible with CAN-Do
garygid 69:6bfdfc002036 180 for(int i=0; i<8; i++){
garygid 69:6bfdfc002036 181 tsMsg.data[i]=' ';
garygid 69:6bfdfc002036 182 if( i < iMsgLen ) tsMsg.data[i]=errMsg[i];
garygid 69:6bfdfc002036 183 }
garygid 69:6bfdfc002036 184 logCan(0,tsMsg); // FFE Comment Message
TickTock 13:62e0f7f39ff5 185 }
TickTock 13:62e0f7f39ff5 186
TickTock 78:a383971fe02f 187 void sendReq() {
TickTock 78:a383971fe02f 188 static char data[8] = {0x02, 0x21, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff};
TickTock 78:a383971fe02f 189 if(reqMsgCnt<99){
TickTock 78:a383971fe02f 190 switch (reqMsgCnt){
TickTock 78:a383971fe02f 191 case 0:
TickTock 78:a383971fe02f 192 can1.monitor(false); // set to active mode
TickTock 78:a383971fe02f 193 can1SleepMode = 0; // enable TX
TickTock 79:68f0dd8d1f19 194 data[0]=0x02; //change to request group 1
TickTock 78:a383971fe02f 195 data[1]=0x21;
TickTock 78:a383971fe02f 196 data[2]=0x01;
TickTock 78:a383971fe02f 197 break;
TickTock 79:68f0dd8d1f19 198 case 6: // group 1 has 6 frames
TickTock 78:a383971fe02f 199 can1.monitor(false); // set to active mode
TickTock 78:a383971fe02f 200 can1SleepMode = 0; // enable TX
TickTock 79:68f0dd8d1f19 201 data[0]=0x02; //change to request group 2 (cp data)
TickTock 78:a383971fe02f 202 data[1]=0x21;
TickTock 78:a383971fe02f 203 data[2]=0x02;
TickTock 78:a383971fe02f 204 break;
TickTock 79:68f0dd8d1f19 205 case 35: // group 2 has 29 frames
TickTock 79:68f0dd8d1f19 206 data[0]=0x02; //change to request group 3
TickTock 78:a383971fe02f 207 data[1]=0x21;
TickTock 78:a383971fe02f 208 data[2]=0x03;
TickTock 78:a383971fe02f 209 break;
TickTock 79:68f0dd8d1f19 210 case 40: // group 3 has 5 frames
TickTock 79:68f0dd8d1f19 211 data[0]=0x02; //change to request group 4 (temperature)
TickTock 78:a383971fe02f 212 data[1]=0x21;
TickTock 78:a383971fe02f 213 data[2]=0x04;
TickTock 78:a383971fe02f 214 break;
TickTock 79:68f0dd8d1f19 215 case 43: // group 4 has 3 frames
TickTock 79:68f0dd8d1f19 216 data[0]=0x02; //change to request group 5
TickTock 78:a383971fe02f 217 data[1]=0x21;
TickTock 78:a383971fe02f 218 data[2]=0x05;
TickTock 78:a383971fe02f 219 break;
TickTock 79:68f0dd8d1f19 220 case 54: // group 5 has 11 frames
TickTock 78:a383971fe02f 221 reqMsgCnt = 99;
TickTock 78:a383971fe02f 222 can1SleepMode = 1; // disable TX
TickTock 78:a383971fe02f 223 can1.monitor(true); // set to snoop mode
TickTock 79:68f0dd8d1f19 224 msgReq.detach(); // stop ticker
TickTock 78:a383971fe02f 225 default:
TickTock 78:a383971fe02f 226 data[0]=0x30; //change to request next line message
TickTock 78:a383971fe02f 227 data[1]=0x01;
TickTock 78:a383971fe02f 228 data[2]=0x00;
TickTock 78:a383971fe02f 229 }
TickTock 78:a383971fe02f 230 can1.write(CANMessage(0x79b, data, 8));
TickTock 78:a383971fe02f 231 reqMsgCnt++;
TickTock 78:a383971fe02f 232 }
TickTock 78:a383971fe02f 233 }
TickTock 78:a383971fe02f 234
TickTock 78:a383971fe02f 235 /*void sendCPreq() {
TickTock 13:62e0f7f39ff5 236 char i;
TickTock 13:62e0f7f39ff5 237 char data[8] = {0x02, 0x21, 0x02, 0xff, 0xff, 0xff, 0xff, 0xff};
TickTock 13:62e0f7f39ff5 238 can1.monitor(false); // set to active mode
TickTock 13:62e0f7f39ff5 239 can1SleepMode = 0; // enable TX
TickTock 13:62e0f7f39ff5 240 can1.write(CANMessage(0x79b, data, 8));
garygid 69:6bfdfc002036 241
garygid 69:6bfdfc002036 242 if( ZeroSecTick ) { ZeroSecTick = false; logTS(); } // gg - 0-second EV bus
garygid 69:6bfdfc002036 243
garygid 69:6bfdfc002036 244 logCan(1,CANMessage(0x79b, data, 8)); // Group 2 Request on EV
TickTock 13:62e0f7f39ff5 245 data[0]=0x30; //change to request next line message
TickTock 13:62e0f7f39ff5 246 data[1]=0x01;
TickTock 13:62e0f7f39ff5 247 data[2]=0x00;
TickTock 23:cd03f9c3395e 248 for(i=0;i<29;i++){
TickTock 13:62e0f7f39ff5 249 wait_ms(16); //wait 16ms
TickTock 13:62e0f7f39ff5 250 can1.write(CANMessage(0x79b, data, 8));
TickTock 13:62e0f7f39ff5 251 }
TickTock 13:62e0f7f39ff5 252 can1SleepMode = 1; // disable TX
TickTock 13:62e0f7f39ff5 253 can1.monitor(true); // set to snoop mode
TickTock 13:62e0f7f39ff5 254 }
TickTock 13:62e0f7f39ff5 255
TickTock 13:62e0f7f39ff5 256 void sendTreq() {
TickTock 13:62e0f7f39ff5 257 char i;
TickTock 13:62e0f7f39ff5 258 char data[8] = {0x02, 0x21, 0x04, 0xff, 0xff, 0xff, 0xff, 0xff};
TickTock 13:62e0f7f39ff5 259 can1.monitor(false); // set to active mode
TickTock 13:62e0f7f39ff5 260 can1SleepMode = 0; // enable TX
TickTock 13:62e0f7f39ff5 261 can1.write(CANMessage(0x79b, data, 8));
garygid 69:6bfdfc002036 262
garygid 69:6bfdfc002036 263 if( ZeroSecTick ) { ZeroSecTick = false; logTS(); } // gg - 0-second EV bus
garygid 69:6bfdfc002036 264
garygid 69:6bfdfc002036 265 logCan(1,CANMessage(0x79b, data, 8)); // Group 4 request on EV
TickTock 13:62e0f7f39ff5 266 data[0]=0x30; //change to request next line message
TickTock 13:62e0f7f39ff5 267 data[1]=0x01;
TickTock 13:62e0f7f39ff5 268 data[2]=0x00;
TickTock 23:cd03f9c3395e 269 for(i=0;i<3;i++){
TickTock 13:62e0f7f39ff5 270 wait_ms(16); //wait 16ms
TickTock 13:62e0f7f39ff5 271 can1.write(CANMessage(0x79b, data, 8));
TickTock 13:62e0f7f39ff5 272 }
TickTock 13:62e0f7f39ff5 273 can1SleepMode = 1; // disable TX
TickTock 13:62e0f7f39ff5 274 can1.monitor(true); // set to snoop mode
TickTock 31:082372c83f68 275 }
TickTock 31:082372c83f68 276
TickTock 36:dbd39c315258 277 void autoPollISR() { //This is the ticker ISR for auto-polling
TickTock 33:a277743ebdeb 278 pollCP=true; //Set a flag to do in main loop instead of here
TickTock 78:a383971fe02f 279 } //since ticker blocks other interrupts*/
TickTock 13:62e0f7f39ff5 280
TickTock 78:a383971fe02f 281 void autoPollISR(){
TickTock 78:a383971fe02f 282 reqMsgCnt = 0; //reset message counter
TickTock 79:68f0dd8d1f19 283 msgReq.attach(&sendReq,0.015);
TickTock 78:a383971fe02f 284 }
TickTock 36:dbd39c315258 285 void playbackISR() { //Used for autoplayback
TickTock 36:dbd39c315258 286 step=true;
TickTock 36:dbd39c315258 287 }
TickTock 36:dbd39c315258 288
TickTock 36:dbd39c315258 289 void doNothing(){ //CAN deattach work-around
TickTock 36:dbd39c315258 290 }
TickTock 36:dbd39c315258 291
TickTock 13:62e0f7f39ff5 292 void recieve1() {
TickTock 13:62e0f7f39ff5 293 CANMessage msg1;
TickTock 13:62e0f7f39ff5 294 can1.read(msg1);
garygid 69:6bfdfc002036 295
garygid 69:6bfdfc002036 296 if( ZeroSecTick ) { ZeroSecTick = false; logTS(); } // gg - 0-second EV bus
garygid 69:6bfdfc002036 297
garygid 69:6bfdfc002036 298 logCan(1, msg1); // EVcan Message Received
TickTock 13:62e0f7f39ff5 299 led1 = !led1;
TickTock 13:62e0f7f39ff5 300 }
TickTock 13:62e0f7f39ff5 301
TickTock 13:62e0f7f39ff5 302 void recieve2() {
TickTock 13:62e0f7f39ff5 303 CANMessage msg2;
TickTock 13:62e0f7f39ff5 304 can2.read(msg2);
garygid 69:6bfdfc002036 305
garygid 69:6bfdfc002036 306 if( ZeroSecTick ) { ZeroSecTick = false; logTS(); } // gg - 0-second EV bus
garygid 69:6bfdfc002036 307
garygid 69:6bfdfc002036 308 logCan(2, msg2); // CARcan Message Received
TickTock 13:62e0f7f39ff5 309 led2 = !led2;
TickTock 13:62e0f7f39ff5 310 }
TickTock 13:62e0f7f39ff5 311
TickTock 22:a43df3905863 312 unsigned char buttonX(unsigned short X, unsigned char columns) {
TickTock 22:a43df3905863 313 unsigned char val = X*columns/320;
TickTock 22:a43df3905863 314 return val;
TickTock 22:a43df3905863 315 }
TickTock 22:a43df3905863 316
TickTock 22:a43df3905863 317 unsigned char buttonY(unsigned short Y, unsigned char rows) {
TickTock 22:a43df3905863 318 unsigned short val = Y*rows/240;
TickTock 22:a43df3905863 319 return val;
TickTock 22:a43df3905863 320 }
TickTock 23:cd03f9c3395e 321
TickTock 23:cd03f9c3395e 322 void saveConfig(){
TickTock 23:cd03f9c3395e 323 FILE *cfile;
TickTock 23:cd03f9c3395e 324 cfile = fopen("/local/config.txt", "w");
TickTock 48:d1ce92104a1f 325 fprintf(cfile,"format 3\r\n");
TickTock 23:cd03f9c3395e 326 fprintf(cfile,"x0_off %d\r\n",tt.x0_off);
TickTock 23:cd03f9c3395e 327 fprintf(cfile,"y0_off %d\r\n",tt.y0_off);
TickTock 23:cd03f9c3395e 328 fprintf(cfile,"x0_pp %d\r\n",tt.x0_pp);
TickTock 23:cd03f9c3395e 329 fprintf(cfile,"y0_pp %d\r\n",tt.y0_pp);
TickTock 23:cd03f9c3395e 330 fprintf(cfile,"x1_off %d\r\n",tt.x1_off);
TickTock 23:cd03f9c3395e 331 fprintf(cfile,"y1_off %d\r\n",tt.y1_off);
TickTock 23:cd03f9c3395e 332 fprintf(cfile,"x1_pp %d\r\n",tt.x1_pp);
TickTock 23:cd03f9c3395e 333 fprintf(cfile,"y1_pp %d\r\n",tt.y1_pp);
TickTock 23:cd03f9c3395e 334 fprintf(cfile,"x_mid %d\r\n",tt.x_mid);
TickTock 26:462ccb580472 335 if (dMode[0]==config1Screen)
TickTock 41:8d4609ea7259 336 fprintf(cfile,"dMode0 %d\r\n",mainScreen);
TickTock 26:462ccb580472 337 else
TickTock 26:462ccb580472 338 fprintf(cfile,"dMode0 %d\r\n",dMode[0]);
TickTock 26:462ccb580472 339 if (dMode[1]==config1Screen)
TickTock 41:8d4609ea7259 340 fprintf(cfile,"dMode1 %d\r\n",mainScreen);
TickTock 26:462ccb580472 341 else
TickTock 26:462ccb580472 342 fprintf(cfile,"dMode1 %d\r\n",dMode[1]);
TickTock 35:5acbd8a64a89 343 fprintf(cfile,"ledHi %4.3f\r\n",ledHi);
TickTock 35:5acbd8a64a89 344 fprintf(cfile,"ledLo %4.3f\r\n",ledLo);
TickTock 35:5acbd8a64a89 345 fprintf(cfile,"pollInt %d\r\n",pollInt);
TickTock 35:5acbd8a64a89 346 fprintf(cfile,"scale12V %4.2f\r\n",scale12V);
TickTock 48:d1ce92104a1f 347 fprintf(cfile,"skin %d\r\n",skin);
TickTock 50:83d5864c64a0 348 fprintf(cfile,"dtePeriod %d\r\n",dtePeriod);
TickTock 23:cd03f9c3395e 349 fclose(cfile);
TickTock 23:cd03f9c3395e 350 }
TickTock 23:cd03f9c3395e 351
TickTock 23:cd03f9c3395e 352 void readConfig(){
TickTock 23:cd03f9c3395e 353 FILE *cfile;
TickTock 23:cd03f9c3395e 354 int ff;
TickTock 23:cd03f9c3395e 355 char sTemp[40];
TickTock 23:cd03f9c3395e 356 cfile = fopen("/local/config.txt", "r");
TickTock 23:cd03f9c3395e 357 if (cfile==NULL){ // if doesn't exist --> create
TickTock 23:cd03f9c3395e 358 sprintf(sTemp,"No config file found.\n");
garygid 69:6bfdfc002036 359 logMsg(sTemp); // no config file
TickTock 23:cd03f9c3395e 360 sprintf(sTemp,"Calibrating touch screen.\n");
garygid 69:6bfdfc002036 361 logMsg(sTemp); // calibrating
TickTock 23:cd03f9c3395e 362 //tt.setcal(5570, 34030, 80, 108, 33700, 5780, 82, 108, 32500);// bypass calibration using my values
TickTock 23:cd03f9c3395e 363 tt.calibrate(); // run touchscreen calibration routine
garygid 58:4d06288d75a2 364 // NOTE: calibrates screen 1 first, then screen 0.
TickTock 23:cd03f9c3395e 365 saveConfig();
TickTock 23:cd03f9c3395e 366 } else {
TickTock 48:d1ce92104a1f 367 ledHi = 0.823;
TickTock 48:d1ce92104a1f 368 ledLo = 0.1;
TickTock 48:d1ce92104a1f 369 pollInt = 300;
TickTock 48:d1ce92104a1f 370 scale12V = 16.2;
TickTock 48:d1ce92104a1f 371 skin = ttSkin;
TickTock 48:d1ce92104a1f 372 fscanf(cfile, "format %d\r\n", &ff ) ;
TickTock 23:cd03f9c3395e 373 fscanf(cfile, "x0_off %d\r\n", &tt.x0_off ) ;
TickTock 23:cd03f9c3395e 374 fscanf(cfile, "y0_off %d\r\n", &tt.y0_off ) ;
TickTock 23:cd03f9c3395e 375 fscanf(cfile, "x0_pp %d\r\n", &tt.x0_pp ) ;
TickTock 23:cd03f9c3395e 376 fscanf(cfile, "y0_pp %d\r\n", &tt.y0_pp ) ;
TickTock 23:cd03f9c3395e 377 fscanf(cfile, "x1_off %d\r\n", &tt.x1_off ) ;
TickTock 23:cd03f9c3395e 378 fscanf(cfile, "y1_off %d\r\n", &tt.y1_off ) ;
TickTock 23:cd03f9c3395e 379 fscanf(cfile, "x1_pp %d\r\n", &tt.x1_pp ) ;
TickTock 23:cd03f9c3395e 380 fscanf(cfile, "y1_pp %d\r\n", &tt.y1_pp ) ;
TickTock 23:cd03f9c3395e 381 fscanf(cfile, "x_mid %d\r\n", &tt.x_mid ) ;
TickTock 26:462ccb580472 382 fscanf(cfile, "dMode0 %d\r\n", &dMode[0] ) ;
TickTock 26:462ccb580472 383 fscanf(cfile, "dMode1 %d\r\n", &dMode[1] ) ;
TickTock 35:5acbd8a64a89 384 if(ff>1){
TickTock 48:d1ce92104a1f 385 fscanf(cfile, "ledHi %f\r\n", &ledHi ) ;
TickTock 48:d1ce92104a1f 386 fscanf(cfile, "ledLo %f\r\n", &ledLo ) ;
TickTock 35:5acbd8a64a89 387 fscanf(cfile, "pollInt %d\r\n", &pollInt ) ;
TickTock 48:d1ce92104a1f 388 fscanf(cfile, "scale12V %f\r\n", &scale12V ) ;
TickTock 48:d1ce92104a1f 389 }
TickTock 48:d1ce92104a1f 390 if(ff>2){
TickTock 48:d1ce92104a1f 391 fscanf(cfile, "skin %d\r\n", &skin ) ;
TickTock 50:83d5864c64a0 392 fscanf(cfile, "dtePeriod %d\r\n", &dtePeriod ) ;
TickTock 35:5acbd8a64a89 393 }
TickTock 23:cd03f9c3395e 394 fclose(cfile);
TickTock 48:d1ce92104a1f 395 if(ff<3){//If not latest format, save as latest format
TickTock 35:5acbd8a64a89 396 saveConfig();
TickTock 48:d1ce92104a1f 397 sprintf(sTemp,"Config file format updated.\n");
garygid 69:6bfdfc002036 398 logMsg(sTemp); // config forat updates
TickTock 48:d1ce92104a1f 399 }
TickTock 43:e7f6f80590e3 400 sprintf(sTemp,"Config file loaded.\n");
garygid 69:6bfdfc002036 401 logMsg(sTemp); // config file loaded
TickTock 23:cd03f9c3395e 402 }
TickTock 23:cd03f9c3395e 403 }
TickTock 25:ddf0ec209f03 404
TickTock 25:ddf0ec209f03 405 void upDate(unsigned char field, bool upDownBar){
TickTock 25:ddf0ec209f03 406 struct tm t; // pointer to a static tm structure
TickTock 25:ddf0ec209f03 407 time_t seconds ;
TickTock 25:ddf0ec209f03 408 seconds = time(NULL);
TickTock 25:ddf0ec209f03 409 t = *localtime(&seconds) ;
TickTock 25:ddf0ec209f03 410 switch(field){
TickTock 25:ddf0ec209f03 411 case 0: // year
TickTock 25:ddf0ec209f03 412 if (upDownBar) {
TickTock 25:ddf0ec209f03 413 t.tm_year = t.tm_year+1;
TickTock 25:ddf0ec209f03 414 } else {
TickTock 25:ddf0ec209f03 415 t.tm_year = t.tm_year-1;
TickTock 25:ddf0ec209f03 416 }
TickTock 25:ddf0ec209f03 417 break;
TickTock 25:ddf0ec209f03 418 case 1: // month
TickTock 25:ddf0ec209f03 419 if (upDownBar) {
TickTock 25:ddf0ec209f03 420 t.tm_mon = (t.tm_mon<12)?t.tm_mon+1:1;
TickTock 25:ddf0ec209f03 421 } else {
TickTock 25:ddf0ec209f03 422 t.tm_mon = (t.tm_mon>2)?t.tm_mon-1:12;
TickTock 25:ddf0ec209f03 423 }
TickTock 25:ddf0ec209f03 424 break;
TickTock 25:ddf0ec209f03 425 case 2: // day
TickTock 25:ddf0ec209f03 426 if (upDownBar) {
TickTock 25:ddf0ec209f03 427 t.tm_mday = (t.tm_mday<31)?t.tm_mday+1:1;
TickTock 25:ddf0ec209f03 428 } else {
TickTock 25:ddf0ec209f03 429 t.tm_mday = (t.tm_mday>2)?t.tm_mday-1:31;
TickTock 25:ddf0ec209f03 430 }
TickTock 25:ddf0ec209f03 431 break;
TickTock 25:ddf0ec209f03 432 case 3: // hour
TickTock 25:ddf0ec209f03 433 if (upDownBar) {
TickTock 25:ddf0ec209f03 434 t.tm_hour = (t.tm_hour<23)?t.tm_hour+1:0;
TickTock 25:ddf0ec209f03 435 } else {
TickTock 25:ddf0ec209f03 436 t.tm_hour = (t.tm_hour>1)?t.tm_hour-1:23;
TickTock 25:ddf0ec209f03 437 }
TickTock 25:ddf0ec209f03 438 break;
TickTock 25:ddf0ec209f03 439 case 4: // minute
TickTock 25:ddf0ec209f03 440 if (upDownBar) {
TickTock 25:ddf0ec209f03 441 t.tm_min = (t.tm_min<59)?t.tm_min+1:0;
TickTock 25:ddf0ec209f03 442 } else {
TickTock 25:ddf0ec209f03 443 t.tm_min = (t.tm_min>1)?t.tm_min-1:59;
TickTock 25:ddf0ec209f03 444 }
TickTock 25:ddf0ec209f03 445 break;
TickTock 25:ddf0ec209f03 446 case 5: // second
TickTock 25:ddf0ec209f03 447 if (upDownBar) {
TickTock 25:ddf0ec209f03 448 t.tm_sec = (t.tm_sec<59)?t.tm_sec+1:0;
TickTock 25:ddf0ec209f03 449 } else {
TickTock 25:ddf0ec209f03 450 t.tm_sec = (t.tm_sec>1)?t.tm_sec-1:59;
TickTock 25:ddf0ec209f03 451 }
TickTock 25:ddf0ec209f03 452 break;
TickTock 25:ddf0ec209f03 453 default:
TickTock 25:ddf0ec209f03 454 break;
TickTock 25:ddf0ec209f03 455 }
TickTock 25:ddf0ec209f03 456 set_time(mktime(&t));
TickTock 25:ddf0ec209f03 457 }
TickTock 25:ddf0ec209f03 458
TickTock 39:eef8beac7411 459 void logPackVoltages() { // Turbo3 - routine to dump CP values to text file
TickTock 39:eef8beac7411 460 char sTemp[40];
TickTock 39:eef8beac7411 461 struct tm t; // pointer to a static tm structure
TickTock 39:eef8beac7411 462 short unsigned max, min, jv, i, bd;
TickTock 39:eef8beac7411 463 unsigned avg;
TickTock 39:eef8beac7411 464 unsigned short gids, SOC, packV;
TickTock 39:eef8beac7411 465 signed short packA;
TickTock 39:eef8beac7411 466 time_t seconds ;
TickTock 39:eef8beac7411 467
TickTock 39:eef8beac7411 468 CANMessage msg;
TickTock 39:eef8beac7411 469
TickTock 39:eef8beac7411 470 seconds = time(NULL); // Turbo3
TickTock 39:eef8beac7411 471 t = *localtime(&seconds) ; // Turbo3
TickTock 39:eef8beac7411 472
TickTock 39:eef8beac7411 473 msg = lastMsg[indexLastMsg[0x5bc]]; //Get gids
TickTock 39:eef8beac7411 474 gids = (msg.data[0]<<2)+(msg.data[1]>>6);
TickTock 39:eef8beac7411 475 msg = lastMsg[indexLastMsg[0x55b]]; //Get SOC
TickTock 39:eef8beac7411 476 SOC = (msg.data[0]<<2)+(msg.data[1]>>6);
TickTock 39:eef8beac7411 477 msg = lastMsg[indexLastMsg[0x1db]]; //Get pack volts
TickTock 39:eef8beac7411 478 packV = (msg.data[2]<<2)+(msg.data[3]>>6);
TickTock 39:eef8beac7411 479 packA = (msg.data[0]<<3)+(msg.data[1]>>5);
TickTock 39:eef8beac7411 480 if (packA & 0x400) packA |= 0xf800;
TickTock 39:eef8beac7411 481
TickTock 39:eef8beac7411 482 max=0;
TickTock 39:eef8beac7411 483 min=9999;
TickTock 39:eef8beac7411 484 avg=0;
TickTock 39:eef8beac7411 485 for(i=0; i<96; i++) {
TickTock 39:eef8beac7411 486 bd=(battData[i*2+3]<<8)+battData[i*2+4];
TickTock 39:eef8beac7411 487 avg+=bd;
TickTock 39:eef8beac7411 488 if(bd>max) max=bd;
TickTock 39:eef8beac7411 489 if(bd<min) min=bd;
TickTock 39:eef8beac7411 490 }
TickTock 39:eef8beac7411 491 avg /= 96;
TickTock 39:eef8beac7411 492 if(min<3713) {
TickTock 39:eef8beac7411 493 jv=avg-(max-avg)*1.5;
TickTock 39:eef8beac7411 494 } else { // Only compute judgement value if min cellpair meets <= 3712mV requirement
TickTock 39:eef8beac7411 495 jv=0;
TickTock 39:eef8beac7411 496 }
TickTock 39:eef8beac7411 497
TickTock 39:eef8beac7411 498 FILE *bfile;
TickTock 39:eef8beac7411 499 //bfile = fopen("/local/batvolt.txt", "a");
TickTock 39:eef8beac7411 500 bfile = fopen("/usb/batvolt.txt", "a");
TickTock 39:eef8beac7411 501 if(bfile!=NULL) {
TickTock 39:eef8beac7411 502 strftime(sTemp, 40, "%a %m/%d/%Y %X", &t);
TickTock 39:eef8beac7411 503 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 39:eef8beac7411 504 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 505 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 39:eef8beac7411 506 for(i=0; i<96; i++) {
TickTock 39:eef8beac7411 507 bd=(battData[i*2+3]<<8)+battData[i*2+4];
TickTock 39:eef8beac7411 508 fprintf(bfile,",%d",bd);
TickTock 39:eef8beac7411 509 }
TickTock 39:eef8beac7411 510 fprintf(bfile,"\r\n");
TickTock 39:eef8beac7411 511 fclose(bfile);
TickTock 39:eef8beac7411 512 }
TickTock 39:eef8beac7411 513 logCP=false;
TickTock 40:0e6e71a7323f 514 showCP=true;
TickTock 39:eef8beac7411 515 }
TickTock 25:ddf0ec209f03 516