Vehicle Data rev_20

/********* 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 22:29:37

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

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

/* START CODE */

/****** DEFINITION OF LIBRARIES *****/
#include <SoftwareSerial.h>

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

/***** DEFINITION OF Software Serial *****/
// Bluetooth HC05 module pins
const uint8_t HC05_BluetoothModule_HC05_mySerial_PIN_SERIAL_TX_A0 = A0;
const uint8_t HC05_BluetoothModule_HC05_mySerial_PIN_SERIAL_RX_A1 = A1;
SoftwareSerial HC05_BluetoothModule_HC05_mySerial(HC05_BluetoothModule_HC05_mySerial_PIN_SERIAL_RX_A1, HC05_BluetoothModule_HC05_mySerial_PIN_SERIAL_TX_A0);

// Define other pins and variables used in the code
const int ALDLTestPin = 2; // Example pin, define as per your hardware
const int DecodeDataOutputPin = 3; // Example pin, define as per your hardware
const int HexDataOutputPin = 4; // Example pin, define as per your hardware

byte M1Cmd[4] = {0x80, 0x95, 0x01, 0x00}; // Example command, define as per your protocol
byte DataBytes[65]; // Buffer for data bytes
const int ByteCount = 64; // Total number of data bytes expected
int linecount = 16; // Number of bytes per line in hex output
int bytecounter = 0; // Counter for hex output formatting

// Variables for parsed data
unsigned long RPM;
float TPS;
float MAF;
byte BLCELL;
byte BLM;
byte INTEGRATOR;
float InjPW;
float O2mv;
float MAT;
unsigned long Runtime;

// Flags and timers
bool SilenceFound = false;
bool PreambleFound = false;
unsigned long PreambleTimer = 0;
byte ALDLbyte = 0;

// Preamble pattern
byte Preamble[3] = {0x80, 0x95, 0x01};

// Function prototypes
float T_interpolate(byte DS_Temp);

void setup(void)
{
  // put your setup code here, to run once:
  HC05_BluetoothModule_HC05_mySerial.begin(9600);
  // Initialize serial communication for debugging/output
  Serial.begin(115200);
  // Initialize serial1 at 8192 baud for ALDL data
  Serial1.begin(8192);
  delay(1500);
  Serial.println("Ready for data capture");
  // Initialize I/O pins
  pinMode(ALDLTestPin, INPUT);
  pinMode(DecodeDataOutputPin, INPUT_PULLUP);
  pinMode(HexDataOutputPin, INPUT_PULLUP);
}

void loop() {
  // Wait for silence period on the ALDL
  Serial.print("wait for silence ");
  SilenceFound = false; // Reset silence flag
  unsigned long StartTime = micros(); // Start timer
  while ((micros() - StartTime) < 15000) { // Wait 15 ms silence
    if (digitalRead(ALDLTestPin) == 0) { // Any activity resets timer
      StartTime = micros();
    }
  }
  SilenceFound = true; // Silence detected

  while (SilenceFound == true) { // Loop while silence is detected
    PreambleFound = false; // Reset preamble flag
    // Send Mode 1 command
    Serial.print(" M1 cmd ");
    int i = 0;
    while (i < 4) {
      Serial1.write(M1Cmd[i]);
      i++;
    }
    Serial.println(" Finding Preamble  ");
    i = 0; // Reset index for preamble detection
    PreambleTimer = millis(); // Start timeout timer
    while ((millis() - PreambleTimer) < 100 && PreambleFound == false) {
      if (Serial1.available() > 0) {
        ALDLbyte = Serial1.read();
        if (ALDLbyte == Preamble[i]) {
          i++;
          if (i > 2) PreambleFound = true; // Preamble detected
        } else {
          PreambleFound = false;
          i = 0; // Reset if mismatch
        }
      }
    }
    if (PreambleFound) {
      // Read data bytes
      int DataStreamIndex = 1;
      while (DataStreamIndex < 65) {
        if (Serial1.available() > 0) {
          DataBytes[DataStreamIndex] = Serial1.read();
          DataStreamIndex++;
        }
      }
      // Calculate checksum
      int i = 1;
      unsigned long CheckTotal = 0x80 + 0x95 + 0x01; // Sum preamble bytes
      while (i < ByteCount) {
        CheckTotal += DataBytes[i];
        i++;
      }
      byte CheckSum = (byte)(0x200 - CheckTotal);
      // Verify checksum
      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) ");
        }
        // Parse data bytes
        RPM = DataBytes[11] * 25; // Engine RPM
        TPS = DataBytes[10] * 0.019608; // TPS volts
        MAF = ((DataBytes[36] * 256) + (DataBytes[37])) * 0.003906; // MAF gm/sec
        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]);

        // Send data over Bluetooth to Android
        HC05_BluetoothModule_HC05_mySerial.print("RPM:");
        HC05_BluetoothModule_HC05_mySerial.print(RPM);
        HC05_BluetoothModule_HC05_mySerial.print(",TPS:");
        HC05_BluetoothModule_HC05_mySerial.print(TPS);
        HC05_BluetoothModule_HC05_mySerial.print(",MAF:");
        HC05_BluetoothModule_HC05_mySerial.print(MAF);
        HC05_BluetoothModule_HC05_mySerial.print(",BLCELL:");
        HC05_BluetoothModule_HC05_mySerial.print(BLCELL);
        HC05_BluetoothModule_HC05_mySerial.print(",BLM:");
        HC05_BluetoothModule_HC05_mySerial.print(BLM);
        HC05_BluetoothModule_HC05_mySerial.print(",INTEGRATOR:");
        HC05_BluetoothModule_HC05_mySerial.print(INTEGRATOR);
        HC05_BluetoothModule_HC05_mySerial.print(",InjPW:");
        HC05_BluetoothModule_HC05_mySerial.print(InjPW);
        HC05_BluetoothModule_HC05_mySerial.print(",O2mv:");
        HC05_BluetoothModule_HC05_mySerial.print(O2mv);
        HC05_BluetoothModule_HC05_mySerial.print(",MAT:");
        HC05_BluetoothModule_HC05_mySerial.print(MAT);
        HC05_BluetoothModule_HC05_mySerial.print(",Runtime:");
        HC05_BluetoothModule_HC05_mySerial.println(Runtime);

        // Display parsed data
        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 for readability
        unsigned long StartTimeDelay = millis();
        while (millis() - StartTimeDelay < 3000) {
          if (Serial1.available() > 0) ALDLbyte = Serial1.read(); // Flush buffer
        }
      } else if (digitalRead(HexDataOutputPin) == LOW) {
        // Send hex data
        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 + 1) {
          Serial.print(DataBytes[j], HEX);
          j++;
          bytecounter++;
          if (bytecounter >= linecount) {
            bytecounter = 0;
            Serial.println();
          } else {
            Serial.print(" ");
          }
        }
        Serial.println();
      } else {
        // Send raw data
        Serial.write(0x80);
        Serial.write(0x95);
        Serial.write(0x01);
        for (int j = 1; j < ByteCount + 1; j++) {
          Serial.write(DataBytes[j]);
        }
      }
    }
  }
}

// Implementation of T_interpolate function
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;
}