I am using an Arduino Mega 2560 with 2 MAX31850's to record ait and exhaust gas temperature. The date is send from the cars ECU to the arduino then to the laptop, This part works fine. Now, I am trying to add the data from the thermo couples into the ECU datastream. Using the sketch below but the Computer isnt seeing the data from the onewire.
I tried the dallas multiple example and it all worked fine
I didnt write the sketch BTW, is from someone working on the same project but they are non using onewire
Code: Select all
/* Written by Venderbroeck. */
/*free to use, but a reference would be nice =) */
//setting up onewire temperature stuff
#include <OneWire.h>
#include <DallasTemperature.h>
#include <LiquidCrystal.h>
// Data wire is plugged into port 2 on the Arduino
#define ONE_WIRE_BUS 6
// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);
//pass oneWire reference to Dallas Temperature
DallasTemperature sensors(&oneWire);
// assign device address manually. the addresses below will beed to be changed
// to valid device addresses on your bus. So find these first with a seperate sketch.
uint8_t Thermo1[8] = {0x3B, 0x08, 0x2F, 0x18, 0x00, 0x00, 0x00, 0xB0};
uint8_t Thermo2[8] = {0x3B, 0x89, 0x32, 0x18, 0x00, 0x00, 0x00, 0xFD};
//Setting up LCD
LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // set LCD interface pins
/*declaring some variables to use in the code*/
//creating arrays to store dataframes in.
//'storage' is used to store a ECU dataframe. Arduino can make use of the data present in the array.
//The array is refreshed everytime a new dataframe comes in.
//storage2 is used for the arduino dataframe to send arduino data to pc.
//storage2 will need to be bigger if you want to store
//more variables from additional inputs.
int storage[60]; //ecudataframe[60]
int storage2[26]; //arddataframe[26]
//declaring variables byteIn, and byteIn2 in which to temporarely store bytes recieved by
//the two serial connections.
int byteIn = 0; //same
int byteIn2 = 0; //same
//declaring bools for header recognition script
bool checkheader1 = false;
bool checkheader2 = false;
//declaring trigger bool, used to trigger void loop script
bool trigger = false; //frametrigger
//counter for the loop filling the storage array with data from the ECU
int i = 1; // same
//counter for sending storage2 contents to PC.
int j = 1; // same
//header and footer used when sending arduino frame
int header1 = 95; //0x5F
int header2 = 175; //0xAF
int footer1 = 180; //0xB4
int footer2 = 100; //0x64
//vars for EGT
long egttemp = 0;
byte egtfinal = 0;
//vars for IAT
int iattemp = 0;
byte iatfinal = 0;
//Declaring the vars first. I just do this to keep track of the
//vars I'm using, and their function. Making them 0 first, their value
//will be updated when the trigger is set, indicating new ECU data has
//been received.
int RPMvalue = 0;
int IDCvalue = 0;
int TPSvalue = 0;
int AFRvalue = storage[12];
/*void setup is ran once at startup. Here the (empty) arduino dataframe skeleton
is created, and the serial connections are initialized*/
void setup() {
/*configuring lcd stuff*/
lcd.begin(20, 4); // set the LCD's columns and rows
// Setup static characters on the lcd
lcd.setCursor(2,0);
lcd.print("RPM:");
lcd.setCursor(2,1);
lcd.print("IDC:");
lcd.setCursor(2,2);
lcd.print("TPS:");
lcd.setCursor(2,3);
lcd.print("AFR:");
/*configuring onewire temperature stuff*/
// Start up the library
sensors.begin();
// set the resolution to 9 bit
sensors.setResolution(Thermo1, 9);
sensors.setResolution(Thermo2, 9);
/*storing the header and footer data in the storage2 array, thus constructing
the arduino data frame skeleton. if you want to store more data in the frame,
the footer bytes need to be moved (and the array enlarged) to allow for the data to
be stored in between. So in this example four variables can be sent with the arduino frame.*/
storage2[1] = header1;
storage2[2] = header2;
storage2[7] = footer1;
storage2[8] = footer2;
/*start up the serial connections
serial (=serial0) is used for USB connectivity.
serial3 is connected to the ECU k-line through a MC33290 chip connected to pins 14, and 15*/
Serial.begin(125000);
Serial3.begin(125000);
}
/* Void loop is the main loop which is ran continuously.
The script it contains sends the arduino dataframe to the pc, when the storing
of the incoming ECU frame is completed.
Instead or alongside of this, you can add any code you want, to manipulate the data in the arrays.
Things like lcd screens, buzzers, and buttons come to mind.*/
void loop() {
/* this script get data from some arduino analog pins and stores them in storage2
in between header and footer.
It's important to realize, the arduino uses values 0-1023 to define the state of an analog
pin. To be able to store it in a byte (0-255) I just divide by 4.
The script only runs when the array is fully updated (trigger == true).
This is to maintain synchronisation between the ECU and Arduino dataframes.
This may not allways be needed, but it can provide a way of throtteling things
like lcd refreshes etc.*/
if (trigger == true) {
//example of fetch and calculation of egt temp
//here egt temperature is devided by 4 to make it fit into a single byte
//you need to multiply the value by 4 again in Tunerpro.
egttemp = sensors.getTempC(Thermo1);
egttemp = egttemp / 4;
egtfinal = egttemp;
storage2[3] = egtfinal;
//example of fetch and calculation of IAT temp
//here division by 4 isn't needed because the iat temp isn't expected
//to reach over 255 degrees C. (Both these temps are in celcius they can be converted
//to fahrenheid like in the example).
iattemp = sensors.getTempC(Thermo2);
iattemp = iattemp / 4;
iatfinal = iattemp;
storage2[4] = iatfinal;
//fetching analog pin 0
// storage2[5] = analogRead(0) / 4;
//fetching analog pin 10
// storage2[6] = analogRead(10) / 4;
/*the following script sends data from storage2 through serial (USB). */
//reset j first
j = 1;
//send the frame byte by byte from the storage2 array
while (j < 9){
Serial.write(storage2[j]);
j++;
}
/*all the extra stuff has been sent to the PC, so now we update the LCD*/
//rpm start
// calculations to get rpm
RPMvalue = (RPMvalue * 30);
lcd.setCursor(8,0);
lcd.print(RPMvalue,1); // Prints the rpm figure
//rpm end
//idc start
// calculations to get idc
IDCvalue = (((IDCvalue *2)/1000)/1200);
lcd.setCursor(8,1);
lcd.print(IDCvalue,1); // Prints the idc figure
//idc end
//tps start
// calculations to get rpm
TPSvalue = (TPSvalue *0.4166667);
lcd.setCursor(8,2);
lcd.print(TPSvalue,1); // Prints the tps figure
//tps end
//afr start
// calculations to get rpm
AFRvalue = (AFRvalue -80);
lcd.setCursor(8,3);
lcd.print(AFRvalue,1); // Prints the afr figure
//afr end
/*end of lcd updating procedure*/
//reset the trigger to exit the script after sending the frame
trigger = false;
}
}
/*the next script runs when the arduino recieves bytes on serial (= serial0 = USB) from the computer.
void serialEvent runs in between individual void loop iterations, so if the void
loop takes too long to complete, serial data will build up and fill the buffer,
probably causing a crash. Using delay() in the main loop is, therefore, not recommended.
Incoming bytes are sent directly through to the ECU over serial3,
so commands can be given to the ECU in the usual way.*/
void serialEvent() {
//Run the while loop for as long as serial data is available.
while (Serial.available() ) {
//reset byteIn variable. Might be redundant.
byteIn2 = 0;
//take byte out of the buffer and store it in byteIn2.
byteIn2 = Serial.read();
}
//send byteIn2 to ECU
Serial3.write(byteIn2);
//If the hex number 0xEE is sent from the PC, Arduino responds with dataframe
//This can be used for testing in realterm for example.
if(byteIn2 == 0xEE) {
trigger = true;
}
}
/*the next script runs when the arduino recieves bytes on serial3 (from the ECU).
void serialEvent3 runs in between individual void loop iterations, so if the void
loop takes too long to complete, serial data will build up and fill the buffer,
probably causing a crash. Using delay() in the main loop is, therefore, not recommended.
Any recieved bytes are sent directly through to the PC via serial, to ensure the datastream
to the PC isn't interrupted.
Meanwhile it will look for the ECU headerstring in the data it recieves
from the ECU. If the headerstring is found, it will store the next 46 bytes
(the body of the ECU dataframe) at the corresponding positions in the array 'storage'.
The ECU header and footer bytes are clipped off, so rpm will be at storage[1] etc.).
All the positions of the data in the ECU dataframe can be found in the standard adx file.
Keep in mind the adx file starts at 0, and the 'storage' array starts at 1, so increment the
position of the value in the adx file by 1 to find it in the 'storage' array.
This means the dataframe from the ECU can be used by the arduino to do whatever
you want with.
Finally when the array is fully updated, the frame is assumed to be received, and so
the trigger is set to true to trigger the script in void loop to do work and send the arduino frame
directly after the ECU frame.
This way the arduino, and the ECU dataframes are allways synced.*/
void serialEvent3() {
//Run the while loop for as long as serial data is available.
//Keep in mind the whole loop will iterate once for each incoming byte.
while (Serial3.available() ) {
//reset byteIn variable. Might be redundant.
byteIn = 0;
//take byte out of the serial 3 buffer and store it.
byteIn = Serial3.read();
//send the byte directly through serial connection 0 (USB)
Serial.write(byteIn);
/*the next if statements need to be ran in this specific order.
They look for the header and store the ECU dataframe in 'storage' for
later use by the arduino. The bytes they store have allready been forwarded to
the USB serial connection, so this array is purely meant for use by the arduino.
This pile of statements still needs refinement
ECU header = 5A A5
ECU footer = AA 5F */
//If both the headerbytes have been recieved and i == 49,
//the loop storing the body has allready been completed, so
//both checkheader triggers reset to false and i resets to 1
//Also it will set the void loop trigger to true to run the script it contains.
if (checkheader1 == true && checkheader2 == true && i == 47) {
checkheader1 = false;
checkheader2 = false;
trigger = true;
i = 1;
}
//ERRORCHECK
//If first headerbyte was recieved, and the second was not,
//and the byte stored isn't A5, something went
//wrong and checkheader1, and i both reset.
if (checkheader1 == true && checkheader2 == false && byteIn != 0xA5) {
checkheader1 = false;
i = 1;
}
/*The actual part filling the array. Everytime the while(serial available())
loop iterates, and the headertriggers are set true, and nothing was changed
above this will write the byte stored in byteIn to the proper place in storage.
Note that i is incremented here each iteration. When it reaches 47 (all bytes recieved)
all triggers, including i are reset above in the next loop iteration. */
if(checkheader1 == true && checkheader2 == true) {
storage[i] = byteIn;
i++;
}
//if byteIn contains the first headerbyte, checkheader1 is set to true
if (checkheader1 == false && byteIn == 0x5A) {
checkheader1 = true;
}
//if the first headerbyte has been received, and byteIn contains the
//second headerbyte, checkheader 2 is set to true
if(checkheader1 == true && byteIn == 0xA5) {
checkheader2 = true;
}
//end of while serial3.available loop
}
//end of void serial.event3
}
