// reads a serial command to change the calbration value for the fuel consuption algorithm
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++*/
void check_for_next_serial_char() {
if (Serial.available() == 0) {
return;
}
// command format must be "Cal" followed by 4 digit number from 0000 to 9999 ie "Cal0500"
// where 5000 is equivalent to 0 change. Anything above 5000 increases the GPH rate, anything
// below 5000 decreases the GPH rate. example 6120 is a 11.2 percent increase.
// or command may be "Gal" followed by 4 digit number from 0000 to 9999 ie "Gal2413" = 24.13 gallons of fuel
// all other messages are ignored.

// msgStage based on reading incoming bytes: any invalid entry along the way and message stage resets to 0
// 0 no valid message
// 1 got C or G
// 2 got a
// 3 got l
// 4 got first digit
// 5 got second digit
// 6 got third digit
// 7 got fourth digit

incomingByte = Serial.read();

switch(msgStage){
case 0:
if (incomingByte == 67) { // start of Cal (calibration) command "C"
msgStage++;
serialCommandType = 1;
} else if (incomingByte == 71) {// start of Gal (fuel) command "G"
msgStage++;
serialCommandType = 2;
} else { // invalid start of any command
msgStage == 0;
}
break;

case 1:
if (incomingByte == 97) { // ignore all messages except "a"
msgStage++;
} else {
msgStage == 0;
}
break;

case 2:
if (incomingByte == 108) {// ignore all messages except "l", lower case L
msgStage++;
} else {
msgStage == 0;
}
break;

case 3:
if (incomingByte > 47 && incomingByte < 58) { // ignore anything not digit 0 - 9
firstDigit = incomingByte -48;
msgStage++;
} else {
msgStage == 0;
}
break;

case 4:
if (incomingByte > 47 && incomingByte < 58) { // ignore anything not digit 0 - 9
secondDigit = incomingByte -48;
msgStage++;
} else {
msgStage == 0;
}
break;

case 5:
if (incomingByte > 47 && incomingByte < 58) { // ignore anything not digit 0 - 9
thirdDigit = incomingByte -48;
msgStage++;
} else {
msgStage == 0;
}
break;

case 6:
if (incomingByte > 47 && incomingByte < 58) { // ignore anything not digit 0 - 9
fourthDigit = incomingByte -48;
msgStage++;
} else {
msgStage == 0;
}
break;
} // end switch

if (msgStage == 7) { // succesfully got a valid calibration request

dataPayload = (1000 * firstDigit) + (100 * secondDigit) + (10 * thirdDigit) + fourthDigit;

if (serialCommandType == 1) { // calibration command

Serial.print(F("Cal request: "));
Serial.println(dataPayload);

save_IN(dataPayload, 8); // save the number in position 8 of EEprom
calculate_calibration_data(dataPayload); // re calculate the actual calibration number
}

if (serialCommandType == 2) { // fuel capacity command
Serial.print(F("Gal request: "));
Serial.println(dataPayload);

save_IN(dataPayload, 4); // save the number in position 4 of EEprom
calculate_fuel_capacity(dataPayload); // re calculate the actual calibration number
}
msgStage = 0; // reset to wait for next command.
}
} // end check_for_next_serial_char

case 0x1E005000: // 0x1E005000 fuel packet
currCANMessageTime = micros();

if ( currCANMessageTime < prevCANMessageTime) { // allow for timer overflow, very slight undercount
prevCANMessageTime = currCANMessageTime;
// skip reading when timer overflows. Once every 70 minutes.
// I could calculate this, but it's not worth the effort
accumulatedFuelUsage = accumulatedFuelUsage + (fuelFlowThisInterval/2.0); //
return;
}

if (currRpm > 400) { // only accumualte fuel when engine is running
data.payloadArray[0] = buf[7]; // shift the data from CAN buffer to unsigned long
data.payloadArray[1] = buf[6];
data.payloadArray[2] = buf[5];
data.payloadArray[3] = buf[4];

// holley data is in lbs per hour so needs to be converted to microseconds and gallons.
// Higher octane fuels weigh more. There is a calibration number that will get the result
// closer to actual consumption measured. Assumptoin... Gallon of gas is 6 lbs.
// So typical usage is 12 gallons an hour = 72 lbs per hour = 1.2 per minute = .02 per second
// = .000000002 per microsecond

lbsPerHourFromHolley = (float)data.payload / 256.0 ; // remove Holley 256 multiplier
fuelFlowPayload = (int)lbsPerHourFromHolley; // for serial display only

lbsPerHourFromHolley = lbsPerHourFromHolley + (lbsPerHourFromHolley * calibrationPercentage); // adjust per calibration value.

usSinceLastCANMessage = currCANMessageTime - prevCANMessageTime;

fuelFlowThisInterval = ((float)usSinceLastCANMessage / 360000.0) * lbsPerHourFromHolley / 600.0;

accumulatedFuelUsage = accumulatedFuelUsage + fuelFlowThisInterval;

displayValue = (int)(accumulatedFuelUsage + roundingInt499);
} else {
prevCANMessageTime = currCANMessageTime;
}

// display is very slow. Only write to display value when it needs to change.
if (displayValue != prevDisplayValue ) {
if (displayValue > 9999) {
display.setSegments(generalError);
} else {
prevDisplayValue = displayValue;
if (countUpMode) {
display.showNumberDecEx(displayValue, (0x80 >> 1), false);
} else {
if (amountOfFuelInTank - displayValue < -999 ) {
display.setSegments(generalError);
} else {
display.showNumberDecEx(amountOfFuelInTank - displayValue, (0x80 >> 1), false);
}
}
}
}

// just for gettting performance stats to serial port
if (debugOneOn) {
if (millis() - durationMillisCounter > 60000) {
Serial.print(F("5 min gph "));
Serial.println((accumulatedFuelUsage - durationPrevGallons) / 1.6666666 );
durationMillisCounter = millis();
durationPrevGallons = accumulatedFuelUsage;
} // performance stats
}

lastTimeCANgotMsg = millis();
prevCANMessageTime = currCANMessageTime;

// the following is for injector pulsewidth, but not used at this time
data.payloadArray[0] = buf[3]; // shift the data from CAN buffer to unsigned long
data.payloadArray[1] = buf[2];
data.payloadArray[2] = buf[1];
data.payloadArray[3] = buf[0];
currInjPulsewidth = (float)data.payload / 256.0;

break;