Vehicle Data rev_10

/********* Pleasedontcode.com **********

    Pleasedontcode thanks you for automatic code generation! Enjoy your code!

    - Terms and Conditions:
    You have a non-exclusive, revocable, worldwide, royalty-free license
    for personal and commercial use. Attribution is optional; modifications
    are allowed, but you're responsible for code maintenance. We're not
    liable for any loss or damage. For full terms,
    please visit pleasedontcode.com/termsandconditions.

    - Project: Vehicle Data
    - Source Code NOT compiled for: Arduino Mega
    - Source Code created on: 2025-07-11 21:35:53

********* Pleasedontcode.com **********/

/****** SYSTEM REQUIREMENTS *****/
/****** SYSTEM REQUIREMENT 1 *****/
    /* send data from bluetooth to android app */
/****** END SYSTEM REQUIREMENTS *****/

/* START CODE */

/****** DEFINITION OF LIBRARIES *****/
// No additional libraries needed for basic serial communication

/****** FUNCTION PROTOTYPES *****/
void setup(void);
void loop(void);
float T_interpolate(byte DS_Temp); // Prototype for the interpolation function

// Declare Bluetooth serial object
// Assuming Bluetooth module connected to Serial2
// You can change to Serial3 if needed
// For example: HardwareSerial BluetoothSerial(2);
HardwareSerial& BluetoothSerial = Serial2;

void setup()
{
  // **** I/O configuration and setup first
  pinMode(ALDLTestPin, INPUT);                                              // define D4 as an input pin to listen for the 160 baud input data
  pinMode(DecodeDataOutputPin, INPUT_PULLUP);                                // User convenience pin.  Grounding this pin will send Decoded Data to the Serial Port
  pinMode(HexDataOutputPin, INPUT_PULLUP);                                   // User convenience pin.  Grounding this pin will send HEX Data to the Serial Port
  // **** Now, start the serial functions
  Serial.begin(115200);                                                     // Open serial monitoring port
  Serial1.begin(8192);                                                      // Test the capability of esp 8222 to run at 8192 baud directly
  BluetoothSerial.begin(9600);                                                // Initialize Bluetooth serial at 9600 baud
  delay(1500);                                                              // delay for diagnostic print
  Serial.println("Ready for data capture");
  // **** Initialize the variables, flags, etc
  i=0;                                                                      // Reset the preamble index flag
}

void loop() {

// Wait for silence period on the ALDL
Serial.print("wait for silence ");
SilenceFound = false;                                                     // Reset silence flag
StartTime= micros();                                                      // First look for an active signal or a timeout - initialize timer
                                                                          // Should exit this loop on the start of a bit
while ((micros() - StartTime)< 15000)                                     // Wait for a 15 ms silent period
  {
    if (digitalRead(4)== 0)                                               // Any line activity resets the start time
     {
       StartTime= micros();                                               // Timing starts over
     }
  }
SilenceFound = true;                                                      // Set the silence flag on exit

while (SilenceFound == true)                                              // While silence found flag is set, continuously request and transmit Mode 1 data
  {                                                                       // Now send a Mode 1 dump command
   PreambleFound = false;                                                 // Reset preamble found flag

   while (PreambleFound == false)                                         // First look at data until the preamble has been found will read data forever until a preamble is read
   {                                                                      // Loop through this while preamble has not been found
    Serial.print(" M1 cmd ");
    i=0;                                                                  // use bytecounter to send the outgoing Mode1CMD sequence
    while (i<4)
    {
      Serial1.write(M1Cmd[i]);                                            // sends 1 byte of the command sequence
      i++;
    }

    Serial.println(" Finding Preamble  ");
    i=0;                                                                  // Then reset byte counter and scan incoming data for the preamble
    PreambleTimer = millis();                                             // Initialize timer to detect timeout
    while ((((millis() - PreambleTimer) < 100)) && (PreambleFound == false))                    // First look at data for 100 ms or until the preamble has been found will read data forever until a preamble is read
      {
        if (Serial1.available() > 0)                                      // Check for available data on the serial port
        {
          ALDLbyte = Serial1.read();                                      // Read it and look for the preamble
          if ( ALDLbyte == Preamble[i])                                   // Look for matching byte of data preamble in serial stream
            {
              i++;                                                        // Increment the preamble index and look for the next character
              if (i>2)PreambleFound = true;                               // Once three characters are found, the preamble has been found, time to read in the data
            }
          else                                                            // If there isn't match, start over looking from the beginning
            {
              PreambleFound = false;                                      // Reset preamble found flag
              i=0;                                                        // Reset the preamble index flag
            }                                                             // End of Preamble check
          }                                                               // End of Serial Available & read
       }                                                                  // End of the preamble finding routine either preamble found or timeout
    }
                                                                          // While loop only exits after a valid preamble is found - *** need to add a timeout option here later
                                                                          // READ A COMPLETE DATA STREAM PACKET
    DataStreamIndex = 1;                                                  // Once a valid preamble has been found set the data stream index to the first byte
    while (DataStreamIndex < 65)                                          // and read data up to byte #63 + 1 byte Checksum = 64 Bytes total
      {
          if (Serial1.available() > 0)                                    // Check for available data on the serial port
            {
              DataBytes[DataStreamIndex] = Serial1.read();                // And read bytes into the array as they come
              DataStreamIndex++;                                          // update the index
            }                                                             // end of read if
      }                                                                   // End of datastream read while - reads 63 bytes of data and skips the checksum byte for new...

    // Checksum Calculation  - Checksum Byte = 0x200 - Sum of all bytes transmitted including the Preamble
    i=1;                                                                  // use bytecounter as an index
    CheckTotal = 0x80+0x95+0x01;                                          // First start by summing the preamble bytes
    while (i< (ByteCount ))                                               // Add recived bytes to the Checksum
      {                                                                   // except the Checksum byte itself
        CheckTotal = CheckTotal + DataBytes[i];                           // add a byte
        i++;
      }
    CheckSum = 0x200 - CheckTotal;                                        // Two's complement the checksum and cast it to a byte
    // Send data over Bluetooth to Android app
    BluetoothSerial.print("Data: ");
    for (int j=1; j<=ByteCount; j++) {
      BluetoothSerial.print(DataBytes[j], HEX);
      BluetoothSerial.print(" ");
    }
    BluetoothSerial.println();

    // now proceed with the original code for checksum verification and data processing
    if (digitalRead(DecodeDataOutputPin) == LOW) {
      // existing code for decoded data output
    } else if (digitalRead(HexDataOutputPin) == LOW) {
      // existing code for hex data output
    } else {
      // existing code for raw binary data output
    }
  }
}

// Keep the T_interpolate function as is
float T_interpolate(byte DS_Temp)                                         // Subroutine to interpolate MAT temperature from data stream
{                                                                         // Input data is one byte of AD from the temperature thermistor (Very Non Linear)
//Temperature scale for interpolating air temperature taken from the ADS file There are 38 values in the table ranging from -40C for a value of 1 to 200 C for a value of 256
  const float TempScale[38] = {1,5,6,9,11,15,19,25,31,38,47,57,67,79,91,104,117,130,142,154,164,175,184,192,200,206,212,217,222,226,230,233,235,238,240,242,244,256};  // Data Values (38)
  const float TempValue[38] = {-40,-30,-25,-20,-15,-10,-5,0,5,10,15,20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100,105,110,115,120,125,130,135,140,145,200}; // Temp Values (38)
  float T_Range;                                                          // Interpolation range
  float T_Diff;                                                           // Difference between input value and the bottom of the interpolation range
  float TempRange;                                                        // Difference between points on the output value scale
  float Temperature;                                                      // Interpolated Temperature value
  int i = 0;
  while (i<38)                                                            // Loop through increasing values to find start of the interpolation
    {
      if  (TempScale[i]> DS_Temp) break;                                  // Until a higher value is found - exit with i pointing to the higher value for interpolation
      i++;
    }
  if (i>0)                                                                // Figure out the linear interpolation range and difference along the scale
    {
      T_Range = TempScale[i] - TempScale[i-1];                            // Range between these points along the input scale (all calculated as a floating point)
      T_Diff =  DS_Temp - TempScale[i-1];                                 // Difference between data and the lower point
      TempRange = TempValue[i] - TempValue[i-1];                          // Difference between points along the output value scale
      Temperature =  TempValue[i-1] + (T_Diff/T_Range)*TempRange;         // Interpolated Temperature
    }
  else Temperature = TempValue[0];                                        // unless the input data is <= to the bottom of the scale and the minimum value is used

  return Temperature;                                                     // Return the interpolated temperature
}