File content as of revision 80:24f1793171e7:

// utility.cpp
#include "utility.h"

void mbed_reset();

void RTC_IRQHandler() {
    timer.reset(); // zero ms at the-seconds-tic
    canIdle=(++secsNoMsg>canTimeout)?true:false;
    userIdle=(++secsNoTouch>userTimeout)?true:false;
    LPC_RTC->ILR |= (1<<0); // clear interrupt to prepare for next
    tick=true;
    // will use this to generate a logTP() just before the next Message received.
    if( (time(NULL) % 60) == 0) ZeroSecTick = true; // gg - at 0-second of each minute
}

void RTC_Init (void) {
    LPC_RTC->ILR=0x00; // set up the RTC interrupts
    LPC_RTC->CIIR=0x01; // interrupts each second
    LPC_RTC->CCR = 0x01;  // Clock enable
    //NVIC_SetPriority( RTC_IRQn, 10 );
    NVIC_EnableIRQ( RTC_IRQn );
}

void logMsg (char *msg) {
    strcpy(displayLog[displayLoc],msg);
    displayLoc=displayLoc>17?0:displayLoc+1;
}

void touch_ISR(){
    //LPC_GPIOINT->IO2IntClr = (LPC_GPIOINT->IO2IntStatR | LPC_GPIOINT->IO2IntStatF); // seems to work without so maybe not necessary (performed inInterruptIn handler?)
    touched=true; // just set flag - touch screen algorythm is long and we don't want to block other interrupts
}

unsigned short getTimeStamp() {
    unsigned short msec = timer.read_ms() ; // read ms from the timer
    unsigned long secs = time(NULL); // seconds past 12:00:00 AM 1 Jan 1900
    unsigned short isecs = secs%60 ; // modulo 60 for 0-59 seconds from RTC
    return ((isecs<<10)+msec) ; // return the two byte time stamp
}

//------------------------------------
// gg - logcan
void logCan (char mType, CANMessage canRXmsg) {
   // re-arranged to put static first
    static unsigned char ii = 0;
    static unsigned char lasti = 0; // indexindex
    static unsigned char bdi=0;
    static signed short imotorRPM = 0;
    static unsigned short nLost = 0; // gg - overrun

    char sTemp[40];    
    unsigned char changed,i;
    unsigned char ij;
    signed short packV;
    signed short packA;
    signed long imWs_x4;
    
    unsigned short ts = getTimeStamp();
    secsNoMsg=0; // reset deadman switch
    
    if(logOpen){
        if(canRXmsg.id>0) {
            // check to see if buffer is already full (read - write) = 1
            // actually the last buffer location cannot be used because then 
            //   the buffer would look empty after writePointer++
            
            //if (((writePointer+maxBufLen-readPointer)%maxBufLen)>(maxBufLen/16)) // modulo is slow?

            // maxBufLen = 512, so pointers are 0 through 511
            if( (readPointer - writePointer) == 1 || (writePointer - readPointer) == (maxBufLen - 1)) {
                // the buffer is "full", so Lose this message
                
                // point to the last-stored message
                int tempWritePointer = writePointer - 1 ;
                if( tempWritePointer == -1 ) tempWritePointer = maxBufLen - 1;
                char strLost[9] ;

                if( nLost == 0 ) {
                    // this is the first message lost 
                    //   and we must overwrite the last message with an FFE comment message
                    // So, there will be two messages lost as the comment message is laid in.
                    nLost = 2;
                    sprintf(strLost,"%s","Lost0002"); // indicate two messages lost
                    
                    // overlay the last message with a "Lost0002" comment
                    writeBuffer[tempWritePointer][0]=0;
                    writeBuffer[tempWritePointer][1]=(ts&0xff00)>>8; // Time Stamp (2 bytes_
                    writeBuffer[tempWritePointer][2]=(ts&0x00ff);
                    writeBuffer[tempWritePointer][3]=0xfe; // MsgID, low byte
                    writeBuffer[tempWritePointer][4]=0xff; // Len nibble, and MsgID high nibble
                        
                    for(i=5;i<13;i++){ 
                        writeBuffer[tempWritePointer][i]= strLost[i-5];
                    }
                } else {
                    // increment the loat counter
                    nLost += 1;
                    
                    // lay the new count into the comment
                    sprintf(strLost,"%04d",nLost);
                    for(i=9;i<13;i++){ 
                        writeBuffer[tempWritePointer][i]= strLost[i-9];
                    }
                }
            } else {
                // is room to insert the message
                // get it inserted quickly
                writeBuffer[writePointer][0]=mType;
                writeBuffer[writePointer][1]=(ts&0xff00)>>8; // Time Stamp (2 bytes_
                writeBuffer[writePointer][2]=(ts&0x00ff);
                writeBuffer[writePointer][3]=canRXmsg.id&0xff; // MsgID, low byte
                writeBuffer[writePointer][4]=(canRXmsg.id>>8)+(canRXmsg.len<<4); // Len nibble, and MsgID high nibble
                for(i=5;i<13;i++){ // Is there a better way to do this? (writeBuffer[writePointer][i]=canRXmsg.data?)
                    writeBuffer[writePointer][i]=canRXmsg.data[i-5];
                }
                //--------------
                // force unused data bytes to FF for CAN-Do compatibility - gg - force FF
                if(canRXmsg.len < 8){
                    for(i=canRXmsg.len; i<8; i++) {
                        writeBuffer[writePointer][i+5]=0xFF;
                    }
                }
                //--------------
                // note, this is not protected from the interrupt
                // due to the nLost code above, this no longer
                //    overflows to writePointer = readPointer
                //    which would make the buffer look empty
                if (++writePointer >= maxBufLen) {
                    writePointer = 0;
                    led3 = !led3;
                }
                //--------------
                // log a local message if we had lost messages. gg - logcan
                if( nLost > 0 ) {
                    // We previously lost messages that did not get into the buffer
                    sprintf(sTemp,"-- Write Buffer Lost [%d]\n", nLost);
                    logMsg(sTemp); // write buffer overrun
                    spkr.beep(500,0.25);
                    
                    nLost = 0 ;
                }
                //--------------
            }
        }
    }
    
    //-------------------------------
    // Some MsgIDS are FFF and FFE, but this array only holds 0 to 7FF
    //   so, only remember messages 7FF or less - gg - logging bug
    if( canRXmsg.id < 0x800 ) {
        // message is 7FF or less - gg - logging bug
        
        // Check if this MsgID has an associated ii entry
        if(indexLastMsg[canRXmsg.id]==0) { 
            // no ii entry associated with this MsgID
            
            // BUG: but ii = 0 is a valid entry after this wraps 
            //ii=ii<99?ii+1:0;
            //ii=ii<99?ii+1:1; // FIX: reserve ii = 0 as the "invalid, not used, entry
            
            if(ii<99) {
                // unused entries are available
                ii += 1; // use next unused entry    
                
                // sever previous usage, if any
                //if( iiUsedBy[ii] != 0 ) indexLastMsg[iiUsedBy[ii]]=0;    
                 
                // keep track of what MsgID is using this ii entry
                //iiUsedBy[ii]=canRXmsg.id; // future                                            
                                                            
                indexLastMsg[canRXmsg.id]=ii; // Create MsgID linkage for first message                               
                
                // update the entry's data
                lastMsg[ii]=canRXmsg; //Store in table
                
                changed = 0xff ; // all bytes are new, so all changed
                msgChanged[ii]=changed;
                
            } else {
                // no more available unused entries
                // so just ignore this MsgID for now
                // ii = 1; // start to re-use entries
                
                // BUG: after this wraps to re-use the ii's, the old MsgID 
                //   that was using this ii needs to be invalidated           
                //indexLastMsg[iiUsedBy[ii]]=0; // invalidate ii entry for old MsgID                     
            }

        } else {
            // there was an old entry for this MsgID to compare to for changes 
            ij = indexLastMsg[canRXmsg.id] ;
            
            // compare the old message with the new one to make the data-changed flags            
            // BUG?: why do this only if viewing the changedScreen?
            if(dMode[0]==changedScreen||dMode[1]==changedScreen){
                
                changed=msgChanged[ij]; // why get the old changed bits
                // what clears the changed bits, dislaying them on the changedScreen?
                
                // compare the 8 old and new data bytes for changes
                for(i=0;i<8;i++){
                    if(lastMsg[ij].data[i]!=canRXmsg.data[i]){
                        changed |= 1<<i;
                    }
                }
                // store the changes
                msgChanged[ij]=changed;
            }
            
            // after the comparison, if any, update the entry's data
            lastMsg[ij]=canRXmsg; // Store in table
        }
    } // end of is 7FF or less

    //-----------------------
    // Miscellaneous on-receive operations below
    if((mType==2)&&(canRXmsg.id==0x358)){ // CAR bus
        // headlight/turn signal indicator
        headlights = (canRXmsg.data[1]&0x80)?true:false;

    //-----------------        
    }else if((mType==1)&&(canRXmsg.id==0x7bb)){ // EV bus
        // is battery-response data?  7bb [0]=SeqNum 1 2 [3]=Group
        // Need to store all responses
        
        // the first SeqNum is 10 (less than 20-2F found later)
        if(canRXmsg.data[0]<0x20){
            // the f1rst response in a series
            if(canRXmsg.data[3]==2){ //cellpair data Group 2
                bdi=0; // initial SeqNum = 10, so index 0
                // next is 21 to 2F and then 20 to about 2C
                sprintf(sTemp,"Getting cell pair data\n");
                logMsg(sTemp);
            }else if(canRXmsg.data[3]==4){ //temperature data Group 4
                bdi=0x20; // index 0 - 2 from SeqNum 20 - 22
                sprintf(sTemp,"Getting temperature data\n");
                logMsg(sTemp);
            }else bdi=0; // strange, BUG? the same as Group 2
            
            lasti=0;
        }
        // handle this response
        i=canRXmsg.data[0]&0x0f; // lower nibble of D0 is index, 0 to F
        if(lasti>i){ //detect rollover to 20 (index 0) and offset index appropriately
            bdi=0x10; // adding 10 to the index for CPs
        }
        lasti=i; //remember the index nibble to detect rollover next time around
        i+=bdi; // 0 to F then 10 through about 1C for CPs
                // 20 through 22 for the Temperatures (Group 4)
        
        //--------------
        // detect last response from the Temperature series.
        //if(i==22) logCP=true; //Turbo3
        //if( (i==22) && (yesBattLog) ) logCP=true; // only if enabled gg - Batt Log 
        if(i==22){
            // is the last response from Temperatures
            logCP=yesBattLog; // Only log if logging enabled
            showCP=true; // Always show
        }
        
        // storing 7 bytes of data from each response (after the SeqNum)
        i*=7;
        if(i<0xfa){ // Is there a better way to do this?
            // for CP data the base is 0, at i is (i*7)+6 and the last is 28*7+6 
            // for Temp data,  base is 32*7, at i is (i*7)+6 and the last is 34*7+6      
            battData[i+0]=canRXmsg.data[1];
            battData[i+1]=canRXmsg.data[2];
            battData[i+2]=canRXmsg.data[3];
            battData[i+3]=canRXmsg.data[4];
            battData[i+4]=canRXmsg.data[5];
            battData[i+5]=canRXmsg.data[6];
            battData[i+6]=canRXmsg.data[7];
        }
    
    //----------------------   
    }else if((mType==1)&&(canRXmsg.id==0x1db)){ // EV bus
        // Battery Volts and Amps
        packV=((canRXmsg.data[2]<<2)|(canRXmsg.data[3]>>6)); // 1 LSB = 0.5V
        packA=((canRXmsg.data[0]<<3)|(canRXmsg.data[1]>>5)); // 1 LSB = 0.5A
        if(packA>0x03ff){
            packA|=0xf800;//extend sign;
        }
        imWs_x4 = packV; // Volts*milliSeconds*2
        imWs_x4 *= -packA; // milliWattseconds*4
        if (!((imotorRPM<2)&&(imWs_x4<0))){ //Ignore if charging from wall
            mWs_x4 += imWs_x4; // total mWs_x4
            numWsamples++;
        }
//-------------------------
#if 0
  }else if((mType==1)&&(canRXmsg.id==0x1db)){ //Battery Volts and Amps
        packV=((canRXmsg.data[2]<<2)|(canRXmsg.data[3]>>6)); // 1 LSB = 0.5V
        packA=((canRXmsg.data[0]<<3)|(canRXmsg.data[1]>>5)); // 1 LSB = 0.5A
        if(packA>0x03ff){
            packA|=0xf800;//extend sign;
        }
        imWs_x4 = packV; // Volts*milliSeconds*2
        imWs_x4 *= -packA; // milliWattseconds*4
        if (!((imotorRPM<2)&&(imWs_x4<0))){ //Ignore if charging from wall
            mWs_x4 += imWs_x4; // total mWs_x4
            numWsamples++;
        }
    }else if((mType==1)&&(canRXmsg.id==0x1da)){ //Motor Speed
        imotorRPM=((canRXmsg.data[4]<<8)|(canRXmsg.data[5]));
        if(imotorRPM<0){ // take absolute value
            imotorRPM=-imotorRPM;
        }
        motorRPM+=imotorRPM;
        numSsamples++;
    }
#endif
//-------------------------        
    }else if((mType==1)&&(canRXmsg.id==0x1da)){ // EV bus
        // Motor Speed
        imotorRPM=((canRXmsg.data[4]<<8)|(canRXmsg.data[5]));
        if(imotorRPM<0){ // take absolute value
            imotorRPM=-imotorRPM;
        }
        motorRPM+=imotorRPM;
        numSsamples++;
    }
}

//---------------------------------
void logTS () {
    CANMessage tsMsg;
    unsigned long secs = time(NULL); // seconds past 12:00:00 AM 1 Jan 1900
    // NOTE: In Mbed, I believe that this is seconds past start of 1970, not 1900
    //   but this is good, since seconds past 1970 is what CAN-Do expects. GG - Date Time
    tsMsg.id=0xfff;
    tsMsg.len=0xf;
    tsMsg.data[0]=secs&0xff; 
    tsMsg.data[1]=(secs>>8)&0xff;
    tsMsg.data[2]=(secs>>16)&0xff;
    tsMsg.data[3]=(secs>>24)&0xff;
    tsMsg.data[4]=0; // 0xff; gg - Date Time
    tsMsg.data[5]=0; // 0xff; for CAN-Do
    tsMsg.data[6]=0; // 0xff;
    tsMsg.data[7]=0xff;
    logCan(0,tsMsg); // Date-Time
}

//----------------------------------
// gg - logevent
void logEvent (char * errMsg) {
    // log CAN-Do 8-character Pseudo Message
    CANMessage tsMsg;
    tsMsg.id=0xffe; // pseudo Message to CAN-Do log
    tsMsg.len=0xf;
    int iMsgLen = strlen(errMsg);
    // 8 character message compatible with CAN-Do
    for(int i=0; i<8; i++){
      tsMsg.data[i]=' '; 
      if( i < iMsgLen ) tsMsg.data[i]=errMsg[i];
    }
    logCan(0,tsMsg); // FFE Comment Message
}

void sendCPreq() {
    char i;
    char data[8] = {0x02, 0x21, 0x02, 0xff, 0xff, 0xff, 0xff, 0xff};
    can1.monitor(false); // set to active mode
    can1SleepMode = 0; // enable TX
    can1.write(CANMessage(0x79b, data, 8));
    
    if( ZeroSecTick ) { ZeroSecTick = false; logTS(); } // gg - 0-second EV bus
    
    logCan(1,CANMessage(0x79b, data, 8)); // Group 2 Request on EV
    data[0]=0x30; //change to request next line message
    data[1]=0x01;
    data[2]=0x00;
    for(i=0;i<29;i++){
        wait_ms(16); //wait 16ms
        can1.write(CANMessage(0x79b, data, 8));
    }
    can1SleepMode = 1; // disable TX
    can1.monitor(true); // set to snoop mode
}

void sendTreq() {
    char i;
    char data[8] = {0x02, 0x21, 0x04, 0xff, 0xff, 0xff, 0xff, 0xff};
    can1.monitor(false); // set to active mode
    can1SleepMode = 0; // enable TX
    can1.write(CANMessage(0x79b, data, 8));
    
    if( ZeroSecTick ) { ZeroSecTick = false; logTS(); } // gg - 0-second EV bus
    
    logCan(1,CANMessage(0x79b, data, 8)); // Group 4 request on EV
    data[0]=0x30; //change to request next line message
    data[1]=0x01;
    data[2]=0x00;
    for(i=0;i<3;i++){
        wait_ms(16); //wait 16ms
        can1.write(CANMessage(0x79b, data, 8));
    }
    can1SleepMode = 1; // disable TX
    can1.monitor(true); // set to snoop mode
}

void autoPollISR() {  //This is the ticker ISR for auto-polling
    pollCP=true;    //Set a flag to do in main loop instead of here
}                   //since ticker blocks other interrupts

void playbackISR() { //Used for autoplayback
    step=true;
}

void doNothing(){ //CAN deattach work-around
}

void recieve1() {
    CANMessage msg1;
    can1.read(msg1);
    
    if( ZeroSecTick ) { ZeroSecTick = false; logTS(); } // gg - 0-second EV bus
    
    logCan(1, msg1); // EVcan Message Received
    led1 = !led1;
}

void recieve2() {
    CANMessage msg2;
    can2.read(msg2);
    
    if( ZeroSecTick ) { ZeroSecTick = false; logTS(); } // gg - 0-second EV bus
    
    logCan(2, msg2); // CARcan Message Received
    led2 = !led2;
}

unsigned char buttonX(unsigned short X, unsigned char columns) {
    unsigned char val = X*columns/320;
    return val;
}

unsigned char buttonY(unsigned short Y, unsigned char rows) {
    unsigned short val = Y*rows/240;
    return val;
}

void saveConfig(){
    FILE *cfile;
    cfile = fopen("/local/config.txt", "w");
    fprintf(cfile,"format 3\r\n");
    fprintf(cfile,"x0_off %d\r\n",tt.x0_off);
    fprintf(cfile,"y0_off %d\r\n",tt.y0_off);
    fprintf(cfile,"x0_pp %d\r\n",tt.x0_pp);
    fprintf(cfile,"y0_pp %d\r\n",tt.y0_pp);
    fprintf(cfile,"x1_off %d\r\n",tt.x1_off);
    fprintf(cfile,"y1_off %d\r\n",tt.y1_off);
    fprintf(cfile,"x1_pp %d\r\n",tt.x1_pp);
    fprintf(cfile,"y1_pp %d\r\n",tt.y1_pp);
    fprintf(cfile,"x_mid %d\r\n",tt.x_mid);
    if (dMode[0]==config1Screen)
        fprintf(cfile,"dMode0 %d\r\n",mainScreen);
    else
        fprintf(cfile,"dMode0 %d\r\n",dMode[0]);
    if (dMode[1]==config1Screen)
        fprintf(cfile,"dMode1 %d\r\n",mainScreen);
    else
        fprintf(cfile,"dMode1 %d\r\n",dMode[1]);
    fprintf(cfile,"ledHi %4.3f\r\n",ledHi);
    fprintf(cfile,"ledLo %4.3f\r\n",ledLo);
    fprintf(cfile,"pollInt %d\r\n",pollInt);
    fprintf(cfile,"scale12V %4.2f\r\n",scale12V);
    fprintf(cfile,"skin %d\r\n",skin);
    fprintf(cfile,"dtePeriod %d\r\n",dtePeriod);
    fclose(cfile);
}

 void readConfig(){
    FILE *cfile;
    int ff;
    char sTemp[40];
    cfile = fopen("/local/config.txt", "r");
    if (cfile==NULL){ // if doesn't exist --> create
        sprintf(sTemp,"No config file found.\n");
        logMsg(sTemp); // no config file
        sprintf(sTemp,"Calibrating touch screen.\n");
        logMsg(sTemp); // calibrating
        //tt.setcal(5570, 34030, 80, 108, 33700, 5780, 82, 108, 32500);// bypass calibration using my values
        tt.calibrate();   // run touchscreen calibration routine
        // NOTE: calibrates screen 1 first, then screen 0.
        saveConfig();
    } else {
        ledHi = 0.823;
        ledLo = 0.1;
        pollInt = 300;
        scale12V = 16.2;
        skin = ttSkin;
        fscanf(cfile, "format %d\r\n", &ff ) ;
        fscanf(cfile, "x0_off %d\r\n", &tt.x0_off ) ;
        fscanf(cfile, "y0_off %d\r\n", &tt.y0_off ) ;
        fscanf(cfile, "x0_pp %d\r\n", &tt.x0_pp ) ;
        fscanf(cfile, "y0_pp %d\r\n", &tt.y0_pp ) ;
        fscanf(cfile, "x1_off %d\r\n", &tt.x1_off ) ;
        fscanf(cfile, "y1_off %d\r\n", &tt.y1_off ) ;
        fscanf(cfile, "x1_pp %d\r\n", &tt.x1_pp ) ;
        fscanf(cfile, "y1_pp %d\r\n", &tt.y1_pp ) ;
        fscanf(cfile, "x_mid %d\r\n", &tt.x_mid ) ;
        fscanf(cfile, "dMode0 %d\r\n", &dMode[0] ) ;
        fscanf(cfile, "dMode1 %d\r\n", &dMode[1] ) ;
        if(ff>1){
            fscanf(cfile, "ledHi %f\r\n", &ledHi ) ;
            fscanf(cfile, "ledLo %f\r\n", &ledLo ) ;
            fscanf(cfile, "pollInt %d\r\n", &pollInt ) ;
            fscanf(cfile, "scale12V %f\r\n", &scale12V ) ;
        }
        if(ff>2){
            fscanf(cfile, "skin %d\r\n", &skin ) ;
            fscanf(cfile, "dtePeriod %d\r\n", &dtePeriod ) ;
        }
        fclose(cfile);
        if(ff<3){//If not latest format, save as latest format
            saveConfig();
            sprintf(sTemp,"Config file format updated.\n");
            logMsg(sTemp); // config forat updates
        }
        sprintf(sTemp,"Config file loaded.\n");
        logMsg(sTemp); // config file loaded
    }
}

void upDate(unsigned char field, bool upDownBar){
    struct tm t; // pointer to a static tm structure
    time_t seconds ;
    seconds = time(NULL);
    t = *localtime(&seconds) ;
    switch(field){
        case 0: // year
            if (upDownBar) {
                t.tm_year = t.tm_year+1;
            } else {
                t.tm_year = t.tm_year-1;
            }
            break;
        case 1: // month
            if (upDownBar) {
                t.tm_mon = (t.tm_mon<12)?t.tm_mon+1:1;
            } else {
                t.tm_mon = (t.tm_mon>2)?t.tm_mon-1:12;
            }
            break;
        case 2: // day
            if (upDownBar) {
                t.tm_mday = (t.tm_mday<31)?t.tm_mday+1:1;
            } else {
                t.tm_mday = (t.tm_mday>2)?t.tm_mday-1:31;
            }
            break;
        case 3: // hour
            if (upDownBar) {
                t.tm_hour = (t.tm_hour<23)?t.tm_hour+1:0;
            } else {
                t.tm_hour = (t.tm_hour>1)?t.tm_hour-1:23;
            }
            break;
        case 4: // minute
            if (upDownBar) {
                t.tm_min = (t.tm_min<59)?t.tm_min+1:0;
            } else {
                t.tm_min = (t.tm_min>1)?t.tm_min-1:59;
            }
            break;
        case 5: // second
            if (upDownBar) {
                t.tm_sec = (t.tm_sec<59)?t.tm_sec+1:0;
            } else {
                t.tm_sec = (t.tm_sec>1)?t.tm_sec-1:59;
            }
            break;
        default:
            break;
    }
    set_time(mktime(&t));
}

void logPackVoltages() { // Turbo3 - routine to dump CP values to text file
    char sTemp[40];
    struct tm t; // pointer to a static tm structure
    short unsigned max, min, jv, i, bd;
    unsigned avg;
    unsigned short gids, SOC, packV;
    signed short packA;
    time_t seconds ;
    
    CANMessage msg;
    
    seconds = time(NULL); // Turbo3
    t = *localtime(&seconds) ; // Turbo3 
    
    msg = lastMsg[indexLastMsg[0x5bc]]; //Get gids
    gids = (msg.data[0]<<2)+(msg.data[1]>>6);
    msg = lastMsg[indexLastMsg[0x55b]]; //Get SOC
    SOC = (msg.data[0]<<2)+(msg.data[1]>>6);
    msg = lastMsg[indexLastMsg[0x1db]]; //Get pack volts
    packV = (msg.data[2]<<2)+(msg.data[3]>>6);
    packA = (msg.data[0]<<3)+(msg.data[1]>>5);
    if (packA & 0x400) packA |= 0xf800;
    
    max=0;
    min=9999;
    avg=0;
    for(i=0; i<96; i++) {
        bd=(battData[i*2+3]<<8)+battData[i*2+4];
        avg+=bd;
        if(bd>max) max=bd;
        if(bd<min) min=bd;
    }
    avg /= 96;
    if(min<3713) {
        jv=avg-(max-avg)*1.5;
    } else { // Only compute judgement value if min cellpair meets <= 3712mV requirement
        jv=0;
    }
    
    FILE *bfile;
    //bfile = fopen("/local/batvolt.txt", "a");
    bfile = fopen("/usb/batvolt.txt", "a");
    if(bfile!=NULL) {
        strftime(sTemp, 40, "%a %m/%d/%Y %X", &t);
        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);
        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]);
        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]);
        for(i=0; i<96; i++) {
            bd=(battData[i*2+3]<<8)+battData[i*2+4];
            fprintf(bfile,",%d",bd);
        }
        fprintf(bfile,"\r\n");
        fclose(bfile);
    }
    logCP=false;
    showCP=true;
}