Create a new version of paste:

/********* 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:50:49

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

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

/* START CODE */

/****** DEFINITION OF LIBRARIES *****/
// No external libraries used

/****** 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, set accordingly
const int HexDataOutputPin = 3;    // Example pin, set accordingly

// Variables
bool SilenceFound = false;
unsigned long StartTime = 0;
unsigned long PreambleTimer = 0;
byte ALDLbyte = 0;
int DataStreamIndex = 1;
const int ByteCount = 64;
byte DataBytes[65];
const byte Preamble[3] = {0x80, 0x95, 0x01};
bool PreambleFound = false;
int i = 0;
unsigned int CheckTotal = 0;
byte CheckSum = 0;
const int linecount = 32;
int bytecounter = 0;
int LineCount = 32; // For hex output formatting

// Mode 1 command sequence
byte M1Cmd[4] = {0x80, 0x95, 0x01, 0x00}; // Example command, set accordingly

// Bluetooth Serial
#include <HardwareSerial.h>
HardwareSerial BluetoothSerial(2); // Use UART2 for Bluetooth

// Additional variables for data
unsigned long PreambleTimer;
float RPM, TPS, MAF, BLCELL, BLM, INTEGRATOR, InjPW, O2mv, MAT, Runtime;

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);                                                      // Serial port for ALDL data
  BluetoothSerial.begin(9600);                                                // Bluetooth serial port at 9600 baud

  delay(1500);                                                              // delay for diagnostic print
  Serial.println("Ready for data capture");
  // Initialize variables
  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

  // Wait for a 15 ms silent period
  while ((micros() - StartTime) < 15000) {
    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
      Serial.print(" M1 cmd ");
      i = 0; // use bytecounter to send the outgoing Mode1CMD sequence
      while (i < 4) {
        Serial1.write(M1Cmd[i]); // send 1 byte of the command sequence
        i++;
      }

      Serial.println(" Finding Preamble  ");
      i = 0; // reset byte counter
      PreambleTimer = millis(); // initialize timer to detect timeout

      while ((millis() - PreambleTimer) < 100 && PreambleFound == false) {
        if (Serial1.available() > 0) {
          ALDLbyte = Serial1.read();
          if (ALDLbyte == Preamble[i]) {
            i++;
            if (i > 2) PreambleFound = true; // Preamble found
          } else {
            PreambleFound = false;
            i = 0;
          }
        }
      }
    }

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

    // Checksum calculation
    i = 1;
    CheckTotal = 0x80 + 0x95 + 0x01;
    while (i < ByteCount) {
      CheckTotal += DataBytes[i];
      i++;
    }
    CheckSum = 0x200 - CheckTotal;

    // Send data over Bluetooth
    if (digitalRead(DecodeDataOutputPin) == LOW) {
      // Send decoded 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 - Decoded Data as follows:   (Page 1) ");
      } else {
        Serial.println(" Checksum *** ERROR *** -  Decoded Data as follows:   (Page 1) ");
      }
      // Send over Bluetooth
      BluetoothSerial.print("Data 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();
    } 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: ");
      }
      // Send over Bluetooth
      BluetoothSerial.print("Hex Data 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();
    } else {
      // Send raw binary data over Bluetooth
      Serial.write(0x80);
      Serial.write(0x95);
      Serial.write(0x01);
      for (int j = 1; j <= ByteCount; j++) {
        Serial.write(DataBytes[j]);
      }
      // Send over Bluetooth
      BluetoothSerial.write(0x80);
      BluetoothSerial.write(0x95);
      BluetoothSerial.write(0x01);
      for (int j = 1; j <= ByteCount; j++) {
        BluetoothSerial.write(DataBytes[j]);
      }
    }
  }
}

// Implementation of the 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;
  float T_Diff;
  float TempRange;
  float 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;
}