Data Transmission rev_03

/********* 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: Data Transmission
    - Source Code NOT compiled for: Arduino Mega
    - Source Code created on: 2025-07-11 20:56:05

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

/****** SYSTEM REQUIREMENTS *****/
/****** SYSTEM REQUIREMENT 1 *****/
    /* send data from bluetooth to android pc */
/****** 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); // Declare the interpolation function

/***** DEFINITION OF Software Serial *****/
const uint8_t hc05_HC05_mySerial_PIN_SERIAL_TX_A0 = A0;
const uint8_t hc05_HC05_mySerial_PIN_SERIAL_RX_A1 = A1;
SoftwareSerial hc05_HC05_mySerial(hc05_HC05_mySerial_PIN_SERIAL_RX_A1, hc05_HC05_mySerial_PIN_SERIAL_TX_A0);

// Define pins for ALDL activity and data output controls
const int ALDLTestPin = 2; // Example pin, set accordingly
const int DecodeDataOutputPin = 3; // Example pin, set accordingly
const int HexDataOutputPin = 4; // Example pin, set accordingly

void setup(void)
{
  // Initialize serial ports
  Serial.begin(115200); // Main serial port for debugging
  Serial1.begin(8192);  // ALDL data at 8192 baud
  hc05_HC05_mySerial.begin(9600); // Bluetooth HC-05 default baud rate
  delay(1500);          // delay for diagnostic print
  Serial.println("Ready for data capture");

  // Initialize I/O pins
  pinMode(ALDLTestPin, INPUT); // Listen for ALDL activity
  pinMode(DecodeDataOutputPin, INPUT_PULLUP); // Decoded data output control
  pinMode(HexDataOutputPin, INPUT_PULLUP); // Hex data output control
}

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

  while (SilenceFound == true) { // Continuous data capture after silence
    // Send Mode 1 command to request data stream
    bool PreambleFound = false;
    uint8_t i = 0;
    unsigned long PreambleTimer;

    // Send Mode 1 command
    Serial.print(" M1 cmd ");
    // Assuming M1Cmd is defined elsewhere; define here if needed
    // For example:
    const byte M1Cmd[4] = {0x68, 0x6A, 0xF1, 0x96}; // Example command
    for (i = 0; i < 4; i++) {
      Serial1.write(M1Cmd[i]);
    }
    Serial.println(" Finding Preamble  ");
    // Search for preamble
    i = 0;
    PreambleTimer = millis();
    while (((millis() - PreambleTimer) < 100) && (PreambleFound == false)) {
      if (Serial1.available() > 0) {
        int ALDLbyte = Serial1.read();
        if (ALDLbyte == Preamble[i]) {
          i++;
          if (i > 2) PreambleFound = true;
        } else {
          PreambleFound = false;
          i = 0;
        }
      }
    }
    // Read data stream
    uint8_t DataStreamIndex = 1;
    byte DataBytes[65]; // 64 bytes + 1 for index
    while (DataStreamIndex < 65) {
      if (Serial1.available() > 0) {
        DataBytes[DataStreamIndex] = Serial1.read();
        DataStreamIndex++;
      }
    }
    // Calculate checksum
    uint32_t CheckTotal = 0x80 + 0x95 + 0x01; // Sum of preamble bytes
    for (i = 1; i < 64; i++) {
      CheckTotal += DataBytes[i];
    }
    byte CheckSum = (0x200 - CheckTotal) & 0xFF; // Two's complement

    // Send data via Bluetooth
    hc05_HC05_mySerial.write(CheckSum); // Send checksum
    for (int j = 1; j <= 64; j++) {
      hc05_HC05_mySerial.write(DataBytes[j]);
    }

    // Output data based on control pins
    if (digitalRead(DecodeDataOutputPin) == LOW) {
      // Decoded data output
      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[64], HEX);
      if (CheckSum == DataBytes[64]) {
        Serial.println(" Checksum GOOD - Decoded Data as follows:   (Page 1) ");
      } else {
        Serial.println(" Checksum *** ERROR *** -  Decoded Data as follows:   (Page 1) ");
      }

      // Parse and display data
      float RPM = DataBytes[11] * 25;
      float TPS = DataBytes[10] * 0.019608;
      float MAF = ((DataBytes[36] * 256) + DataBytes[37]) * 0.003906;
      int BLCELL = DataBytes[21];
      int BLM = DataBytes[20];
      int INTEGRATOR = DataBytes[22];
      float InjPW = ((DataBytes[45] * 256) + DataBytes[46]) * 0.015259;
      float O2mv = DataBytes[17] * 4.44;
      float MAT = T_interpolate(DataBytes[30]);
      unsigned int 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 StartTimeDelay = millis();
      while (millis() < StartTimeDelay + 3000) {
        if (Serial1.available() > 0) ALDLbyte = Serial1.read(); // Flush buffer
      }
    } else if (digitalRead(HexDataOutputPin) == LOW) {
      // Hex data output
      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[64], HEX);
      if (CheckSum == DataBytes[64]) {
        Serial.println(" Checksum GOOD - Data as follows: ");
      } else {
        Serial.println(" Checksum *** ERROR *** -  Data as follows: ");
      }

      // Print hex data
      int j = 1;
      int bytecounter = 0;
      const int linecount = 64;
      while (j <= 64) {
        Serial.print(DataBytes[j], HEX);
        Serial.print(" ");
        bytecounter++;
        if (bytecounter >= linecount) {
          bytecounter = 0;
          Serial.println();
        }
        j++;
      }
      Serial.println();
    } else {
      // Raw binary data stream
      Serial.write(0x80);
      Serial.write(0x95);
      Serial.write(0x01);
      for (int j = 1; j <= 64; j++) {
        Serial.write(DataBytes[j]);
      }
    }
  }
}

// Interpolation function for 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;
}