Data Transmission rev_09

/********* 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 21:28:02

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

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

/* START CODE */

/****** DEFINITION OF LIBRARIES *****/

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

// Define pins
const int ALDLTestPin = 4;
const int DecodeDataOutputPin = 2; // Example pin, adjust as needed
const int HexDataOutputPin = 3;    // Example pin, adjust as needed

// Define command array and other variables
byte M1Cmd[4] = {0x80, 0x95, 0x01, 0x00}; // Example command, adjust as needed
const int ByteCount = 64;
byte DataBytes[65];
int DataStreamIndex = 0;
unsigned long PreambleTimer = 0;
bool PreambleFound = false;
bool SilenceFound = false;
unsigned long StartTime = 0;
int i = 0;
float RPM, TPS, MAF, BLCELL, BLM, INTEGRATOR, InjPW, O2mv, MAT, Runtime;
const int linecount = 32;
int bytecounter = 0;
const byte Preamble[3] = {0x80, 0x95, 0x01};
const int linecount = 32;
unsigned int CheckTotal = 0;
byte ALDLbyte = 0;
float CheckSum = 0;

// Bluetooth serial port
// Adjust the serial port as per your hardware connection
// For example, Serial2 for Mega
// Initialize in setup()

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

  // Initialize serial ports
  Serial.begin(115200);                                                     // Open serial monitoring port
  Serial1.begin(8192);                                                      // Test the capability of esp 8222 to run at 8192 baud directly
  Serial2.begin(9600); // Initialize Bluetooth serial port at 9600 baud (adjust as needed)

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

  // Initialize variables
  i=0;                                                                      // Reset the preamble index flag
}

void loop() {
  // Send data from Bluetooth to Android
  if (Serial2.available() > 0) {
    int btData = Serial2.read();
    Serial.print("Bluetooth data: ");
    Serial.println(btData, HEX);
  }

  // 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
  while ((micros() - StartTime)< 15000) {                                     // Wait for a 15 ms silent period
    if (digitalRead(ALDLTestPin)== 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
    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
      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
        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 if
        } // end if
      } // end while
    } // end while

    // Read complete data 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 if
    } // end while

    // Checksum calculation
    i=1;                                                                  // use bytecounter as an index
    CheckTotal = 0x80+0x95+0x01;                                          // sum preamble bytes
    while (i< (ByteCount )) {                                               // Add received bytes to the checksum
      CheckTotal = CheckTotal + DataBytes[i];                           // add a byte
      i++;
    }
    CheckSum = 0x200 - CheckTotal;                                        // Two's complement the checksum

    // Send data to serial port based on output mode
    if (digitalRead(DecodeDataOutputPin) == LOW) {                          // Check decoded output bit
      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) ");
      }
      // ... (rest of data processing and printing code)
    } else if (digitalRead(HexDataOutputPin) == LOW) {                        // Hex output mode
      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;
      bytecounter = 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 { // Raw binary stream
      Serial.write(0x80);
      Serial.write(0x95);
      Serial.write(0x01);
      for (int j=1; j<ByteCount +1; j++) {
        Serial.write(DataBytes[j]);
      }
    }

    // Send data over Bluetooth to Android
    for (int j=1; j<ByteCount +1; j++) {
      Serial2.write(DataBytes[j]);
    }
  } // end while (SilenceFound)

  // Additional code for processing and other functions...
}

// Implementation of the interpolation 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;
}