Vehicle Data rev_11

/********* 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:40:08

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

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

/* START CODE */

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

/****** FUNCTION PROTOTYPES *****/
void setup(void);
void loop(void);
float T_interpolate(byte DS_Temp);

// Define Bluetooth serial object (assuming HC-05 connected to Serial2)
#define BluetoothSerial Serial2

// Define pins (assuming these are defined elsewhere in the code)
const int ALDLTestPin = 4;
const int DecodeDataOutputPin = 2;
const int HexDataOutputPin = 3;

// Define command and data variables
byte M1Cmd[4] = {0x80, 0x95, 0x01, 0x00}; // Example command, adjust as needed
byte Preamble[3] = {0x80, 0x95, 0x01};
bool SilenceFound = false;
bool PreambleFound = false;
int DataStreamIndex = 0;
const int ByteCount = 64;
byte DataBytes[65];
int linecount = 32;
int bytebytecounter = 0;

// Variables for data processing
unsigned long ALDLbyte;
float RPM, TPS, MAF, O2mv, MAT;
int BLCELL, BLM, INTEGRATOR;
float InjPW;
unsigned long Runtime;

// Initialize Bluetooth in setup
void setup()
{
  // **** I/O configuration and setup first
  pinMode(ALDLTestPin, INPUT);
  pinMode(DecodeDataOutputPin, INPUT_PULLUP);
  pinMode(HexDataOutputPin, INPUT_PULLUP);

  // Initialize serial ports
  Serial.begin(115200);
  Serial1.begin(8192);
  BluetoothSerial.begin(9600); // Initialize Bluetooth serial at 9600 baud

  delay(1500);
  Serial.println("Ready for data capture");

  int i=0; // Reset the preamble index flag
}

// Main loop
void loop() {
  // Wait for silence period on the ALDL
  Serial.print("wait for silence ");
  SilenceFound = false;
  unsigned long StartTime= micros();
  while ((micros() - StartTime) < 15000)
  {
    if (digitalRead(ALDLTestPin) == 0)
    {
      StartTime= micros();
    }
  }
  SilenceFound = true;

  while (SilenceFound == true)
  {
    PreambleFound = false;
    while (PreambleFound == false)
    {
      Serial.print(" M1 cmd ");
      int i=0;
      while (i<4)
      {
        Serial1.write(M1Cmd[i]);
        i++;
      }
      Serial.println(" Finding Preamble  ");
      i=0;
      unsigned long PreambleTimer = millis();
      while ((((millis() - PreambleTimer) < 100)) && (PreambleFound == false))
      {
        if (Serial1.available() > 0)
        {
          ALDLbyte = Serial1.read();
          if (ALDLbyte == Preamble[i])
          {
            i++;
            if (i > 2) PreambleFound = true;
          }
          else
          {
            PreambleFound = false;
            i=0;
          }
        }
      }
    }

    DataStreamIndex = 1;
    while (DataStreamIndex < 65)
    {
      if (Serial1.available() > 0)
      {
        DataBytes[DataStreamIndex] = Serial1.read();
        DataStreamIndex++;
      }
    }

    // Calculate checksum
    int i=1;
    unsigned int CheckTotal = 0x80 + 0x95 + 0x01;
    while (i < ByteCount)
    {
      CheckTotal += DataBytes[i];
      i++;
    }
    byte CheckSum = 0x200 - CheckTotal;

    // Send data over Bluetooth if connected
    // For simplicity, we assume Bluetooth is always connected
    // Send checksum and data bytes
    BluetoothSerial.print("Data received at ");
    BluetoothSerial.print(millis());
    BluetoothSerial.print(" Checksum: ");
    BluetoothSerial.print(CheckSum, HEX);
    BluetoothSerial.print(" Data: ");
    for (int j=1; j<=ByteCount; j++)
    {
      BluetoothSerial.print(DataBytes[j], HEX);
      BluetoothSerial.print(" ");
    }
    BluetoothSerial.println();

    // Check decoded output pin
    if (digitalRead(DecodeDataOutputPin) == LOW)
    {
      Serial.print("New Data Stream received at ");
      Serial.print(millis());
      Serial.print(" Calc CHECKSUM: ");
      Serial.print(CheckSum, HEX);
      Serial.print(" Transmitted CHECKSUM: ");
      Serial.print(DataBytes[ByteCount], HEX);
      if (CheckSum == DataBytes[ByteCount])
        Serial.println(" Checksum GOOD - Decoded Data as follows:   (Page 1) ");
      else
        Serial.println(" Checksum *** ERROR *** -  Decoded Data as follows:   (Page 1) ");

      RPM = DataBytes[11] * 25;
      TPS = DataBytes[10] * 0.019608;
      MAF = ((DataBytes[36] * 256) + (DataBytes[37])) * 0.003906;
      BLCELL = DataBytes[21];
      BLM = DataBytes[20];
      INTEGRATOR = DataBytes[22];
      InjPW = ((DataBytes[45] * 256) + (DataBytes[46])) * 0.015259;
      O2mv = DataBytes[17] * 4.44;
      MAT = T_interpolate(DataBytes[30]);
      Runtime = (DataBytes[52] * 256 + DataBytes[53]);

      Serial.print("Engine Speed     : ");
      Serial.print(RPM);
      Serial.println(" RPM");
      Serial.print("Throttle Position: ");
      Serial.print(TPS);
      Serial.println(" Volts");
      Serial.print("Mass Air Flow    : ");
      Serial.print(MAF);
      Serial.println(" Grams/Sec");
      Serial.print("Current BLM Cell: ");
      Serial.print(BLCELL);
      Serial.print(" BLM Value: ");
      Serial.print(BLM);
      Serial.print("  Current Fuel Integrator: ");
      Serial.println(INTEGRATOR);
      Serial.print("Injector Pulse   : ");
      Serial.print(InjPW);
      Serial.println(" Milliseconds");
      Serial.print("O2 Sensor Voltage: ");
      Serial.print(O2mv);
      Serial.println(" Millivolts");
      Serial.print("Intake Air Temp  : ");
      Serial.print(MAT);
      Serial.println(" Deg C");
      Serial.print("Engine Run Time  : ");
      Serial.print(Runtime);
      Serial.println(" Seconds");

      // Delay to allow user to read data
      unsigned long StartTime = millis();
      while (millis() < StartTime + 3000)
      {
        if (Serial1.available() > 0) ALDLbyte = Serial1.read();
      }
    }
    else if (digitalRead(HexDataOutputPin) == LOW)
    {
      Serial.print("New Data Stream received at ");
      Serial.print(millis());
      Serial.print(" Calc CHECKSUM: ");
      Serial.print(CheckSum, HEX);
      Serial.print(" Transmitted CHECKSUM: ");
      Serial.print(DataBytes[ByteCount], HEX);
      if (CheckSum == DataBytes[ByteCount])
        Serial.println(" Checksum GOOD - Data as follows: ");
      else
        Serial.println("Checksum *** ERROR *** -  Data as follows: ");

      int j=1;
      bytebytecounter = 0;
      while (j<=ByteCount)
      {
        Serial.print(DataBytes[j], HEX);
        Serial.print(" ");
        j++;
        bytebytecounter++;
        if (bytebytecounter >= linecount)
        {
          bytebytecounter=0;
          Serial.println();
        }
      }
      Serial.println();
    }
    else
    {
      // Send raw data stream over serial
      Serial.write(0x80);
      Serial.write(0x95);
      Serial.write(0x01);
      for (int j=1; j<=ByteCount; j++)
      {
        Serial.write(DataBytes[j]);
      }
    }
  }
}

// Interpolates temperature
float T_interpolate(byte DS_Temp)
{
  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};
  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};
  float T_Range, T_Diff, TempRange, Temperature;
  int i=0;
  while (i<38)
  {
    if (TempScale[i] > DS_Temp) break;
    i++;
  }
  if (i>0)
  {
    T_Range = TempScale[i] - TempScale[i-1];
    T_Diff = DS_Temp - TempScale[i-1];
    TempRange = TempValue[i] - TempValue[i-1];
    Temperature = TempValue[i-1] + (T_Diff / T_Range) * TempRange;
  }
  else
  {
    Temperature = TempValue[0];
  }
  return Temperature;
}