Ok I do have some code and hopefully it is well commented enough that you can figure out what's going on. There's a lot of extra functionality going on here (wheel speed input, electronic speedo drive output, output to drive the standard current-based oil pressure gauge via a transistor, CAN data reading etc), and some of that stuff is incomplete or just there for future expansion. Anyway I think you should be able to pick out the various bits that you might need. The i2c communication would need to be changed totally to work with those displays, and I think you'll need to add one or more libraries to get them working
Code: Select all
/*
MR2 Brains
Written by Malcolm Graham
April 2017
This is intended to read sensors and control some outputs - e.g. speedo, possibly other gauges.
Data sent over i2c for an LCD display, possibly other uses (e.g. logger?)
CAN bus - able to send and receive
Functions performed:
- converting pulses into wheel speed
- conversion of voltage to pressure for oil/boost
- conversion of voltage to temperature for NTC temperature sensors, using lookup table
******** To do list **********
* add oil pressure gauge control
* add i2c comms
* finish adding analogue input measurements
* decoding of CAN data - e.g. lambda
* Get GPS speed working
* reduce sample/update rate for temperatures
* change speed reading to rolling average
########## HARDWARE ###########
Analog Inputs:
A0 - Oil pressure
A1 - Boost pressure
A2 - Temp 1
A3 - Temp 2
A4&5 - used for i2c
Digital Pins:
0
1
2 - Wheel speed sensor
3 - CAN interrupt *** possibly relocate to another pin and use as flag rather than interrupt
4 - Software serial Rx (GPS)
5 - reserved for possible software serial Tx
6 - Oil pressure gauge output
7
8
9 - Speed out to instrument cluster
10 - CAN CS
11 - CAN MOSI
12 - CAN MISO
13 - CAN SCK
Incrementing of release number:
Final digit designates changes only for bug fixes, altering numerical factors etc
Second digit increment for functionality changes
First digit increment for major functional changes
*/
#include <Wire.h> // for i2c
#include <SPI.h> // for CAN
#include <mcp_can.h>
#include <mcp_can_dfs.h>
// ******** CAN related **********
#define CAN0_INT 3
MCP_CAN CAN0(10); // Set CS pin
byte flagRecv = 0;
byte len = 0;
byte rxBuf[8];
long unsigned int rxId;;
char msgStr[128];
// ******** i2c related **********
byte i2cb0 = 0xFF;
byte i2cb1 = 0xFF;
byte i2cb2 = 0xFF;
byte i2cb3 = 0xFF;
byte i2cb4 = 0xFF;
byte i2cb5 = 0xFF;
byte i2cb6 = 0xFF;
// ******** speed related *********
#define SPD_IN_PIN 2
#define SPD_OUT_PIN 9
const float wheelCirc = 1.913;
const float toothCount = 6;
const float speedoRatio = 1.46;
//const int spdPin = 10;
volatile byte pulseCount = 0;
unsigned long prevTime = 0;
int vehicleSpeed = 50;
float i, j, k, spdFreq;
// ********** analogue inputs **********
#define OIL_P_PIN A1
#define MAP_PIN A0
#define TEMP1_PIN A2
#define TEMP2_PIN A3
#define SERIESRESISTOR 1000
unsigned int oilP_in, MAP_in;
float oilP_Out, MAP_Out;
unsigned long oilP_offset = 500; // mV
unsigned long MAP_offset = 10; // kPa
float oilP_mult = 0.025; // psi per mV
float MAP_mult = 250; // kPa per mV (this is not correctly scaled yet)
// array with values for temperatures from 0 to 60,
unsigned int tableOhms[] = {5894, 3797, 2498, 1706, 1177, 834, 596, 436, 324, 243, 187, 144, 113, 89};
unsigned int tableC[] = { 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130};
unsigned int temp1[10] = {0,0,0,0,0,0,0,0,0,0};
unsigned int temp2[10] = {0,0,0,0,0,0,0,0,0,0};
float t, tempReading;
int ii, tempVal, therm1x10, therm2x10;
int kk = 0;
unsigned long tempTimer = 0;
// ********** outputs **********
#define OIL_GAUGE_PIN 6
float oilDCperPSI = 1.1;
byte oilDCout = 0;
void setup()
{
// begin serial monitor data
Serial.begin(115200);
// ************ CAN related ***********
if(CAN0.begin(MCP_ANY, CAN_1000KBPS, MCP_16MHZ) == CAN_OK)
Serial.println("MCP2515 Initialized Successfully!");
else
Serial.println("Error Initializing MCP2515...");
CAN0.setMode(MCP_NORMAL);
// attach CAN interrupt
attachInterrupt(digitalPinToInterrupt(CAN0_INT), MCP2515_ISR, FALLING);
// Serial.println("Checkpoint #1");
// ************ i2c related *************
Wire.begin();
// ************ speed related ************
// assign interrupt pin 2 as hall effect input and hold it high
pinMode(SPD_IN_PIN, INPUT);
digitalWrite(SPD_IN_PIN, HIGH);
pinMode(SPD_OUT_PIN, OUTPUT);
//attach the readspeed function as interrupt 0
attachInterrupt(digitalPinToInterrupt(SPD_IN_PIN), ReadSpeed, RISING);
// oil pressure gauge output setup
pinMode(OIL_GAUGE_PIN, OUTPUT);
digitalWrite(OIL_GAUGE_PIN, LOW);
}
// ISR CAN - set flag when message received
void MCP2515_ISR()
{
flagRecv = 1;
}
// ISR for incrementing pulse count
void ReadSpeed()
{
pulseCount++;
}
void loop()
{
// Serial.println("Checkpoint #2");
// ############# CAN data processing ##################
if(flagRecv)
{ // check if get data
flagRecv = 0; // clear flag
// iterate over all pending messages
// If either the bus is saturated or the MCU is busy,
// both RX buffers may be in use and reading a single
// message does not clear the IRQ conditon.
while (CAN_MSGAVAIL == CAN0.checkReceive())
{
// read data, len: data length, buf: data buf
CAN0.readMsgBuf(&rxId, &len, msgStr);
/*
// print the data
for(int i = 0; i<len; i++)
{
Serial.print(buf[i]);Serial.print("\t");
}
Serial.println();*/
if (rxId == 0x0460)
{
Serial.print("Correct ID found \n");
Serial.print("Data byte 6: "); //not sure whether this is actually byte 6!
Serial.print(msgStr[6]);
Serial.println();
}
}
}
// Serial.println("Checkpoint #3");
// ############# i2c data processing ##################
// prepare message bytes
i2cb0 = (byte)vehicleSpeed; // 1kmh/b
i2cb1 = (byte)(oilP_Out * 2.0); // 0.5psi/b
i2cb2 = (byte)MAP_Out; // 1kpa/b
i2cb3 = (byte)(therm1x10 * 0.5); // 0.5degC/b
i2cb4 = (byte)(therm2x10 * 0.5); // 0.5degC/b
// Serial.println("Checkpoint #4");
/*
Wire.beginTransmission(2); // transmit on address 2
Wire.write(i2cb0); // send byte 0
Wire.write(i2cb1); // send byte 1
Wire.write(i2cb2); // send byte 2
Wire.write(i2cb3); // send byte 3
Wire.write(i2cb4); // send byte 4
Wire.endTransmission();*/
// need to add a counter so messages are only sent at say 10Hz
// // Serial print
// Serial.println("Data for i2c:");
// Serial.println(i2cb0);
// Serial.println(i2cb1);
// Serial.println(i2cb2);
// Serial.println(i2cb3);
// Serial.println(i2cb4);
// Serial.println("Checkpoint #5");
// ############# Speed data processing ##################
if (vehicleSpeed > 10)
{
// calculate output frequency for speedo
spdFreq = speedoRatio * vehicleSpeed;
tone(SPD_OUT_PIN, (unsigned int)spdFreq);
}
// when enough speed input pulses have been counted, begin calculation of speed
if (pulseCount >=5 )
{
// calculation is as follows: speed (kmh) = 3.6 * distance (m) / time (s) ---- however this is broken into several steps below, to be unified later after full debugging
i = pulseCount/toothCount;
j = (millis()-prevTime);
k = j/1000;
vehicleSpeed = (unsigned int)(3.6 * ((wheelCirc * i) / k));
// set current time as prevTime for calculation of next 3-pulse period
prevTime = millis();
pulseCount = 0;
}
Serial.print("Speed: ");
Serial.println(vehicleSpeed);
// ############# Temperature processing ##################
// only check temperatures every 500ms (gives 1Hz sample rate per sensor)
if ((millis() - tempTimer) > 500)
{
// store time of current sample/calculation
tempTimer = millis();
//kk is index variable for thermistor number
if (kk == 0)
{
tempReading = analogRead(TEMP1_PIN);
}
else
{
tempReading = analogRead(TEMP2_PIN);
}
// Serial.print("Analog reading ");
// Serial.println(tempReading);
// convert the value to resistance
tempReading = (1023 / tempReading) - 1;
tempReading = SERIESRESISTOR / tempReading;
// create integer of resistance
tempVal = (int)tempReading;
// Serial.print("Thermistor resistance ");
// Serial.println(tempVal);
// i is index variable for table lookup
ii = 0;
while (tempVal < tableOhms[ii] && ii < sizeof(tableOhms))
{
// Serial.println(*tableC[ii,1]);
ii++;
}
// interpolation calculation, define variables to tidy up calc
int ohmsA = tableOhms[ii-1];
int ohmsB = tableOhms[ii];
int tempA = tableC[ii-1];
int tempB = tableC[ii];
t = ((tempVal-ohmsA) * ( (float)(tempB-tempA) / (float)(ohmsB-ohmsA) )) + tempA;
// rolling average calculation, left shift each stored value
for (int jj = 0; jj < 10; jj++)
{
if (kk == 0)
{
temp1[jj] = temp1[jj+1];
}
else
{
temp2[jj] = temp2[jj+1];
}
}
// store latest temperature reading and calculate rolling average
if (kk ==0)
{
temp1[9] = (t*100);
unsigned int t_sum = 0;
for (int jj = 0; jj < 10; jj++)
{
t_sum = t_sum + temp1[jj];
}
t = (float)t_sum/1000;
therm1x10 = t*10;
// Serial.print("Thermistor temperatures: 1 = ");
// Serial.print(therm1x10);
}
else
{
temp2[9] = (t*100);
unsigned int t_sum = 0;
for (int jj = 0; jj < 10; jj++)
{
t_sum = t_sum + temp2[jj];
}
t = (float)t_sum/1000;
therm2x10 = t*10;
//Serial.print(", 2 = ");
//Serial.print(therm2x10);
//Serial.println(" degC");
}
// increment k, then make sure it is less than 2
kk++;
kk = kk % 2;
}
// ############# Pressure processing ##################
oilP_in = analogRead(OIL_P_PIN);
oilP_Out = (oilP_in * (5000 / 1023.0) - oilP_offset) * oilP_mult; // convert to mV, subtract offset, multiply by scaler
MAP_in = analogRead(MAP_PIN);
MAP_Out = (MAP_in / 1023.0) * MAP_mult + MAP_offset;
Serial.print("Oil P: ");
Serial.print(oilP_Out);
Serial.print(" psi, ");
Serial.print(oilP_in * 5);
Serial.println("mV (approx)");
Serial.print("MAP: ");
Serial.print(MAP_Out);
Serial.print(" kPa, ");
Serial.print(MAP_in * 5);
Serial.println("mV (approx)");
// ############# Oil pressure gauge control ##################
oilDCout = (byte)(oilP_Out * oilDCperPSI);
analogWrite(OIL_GAUGE_PIN,oilDCout);
}
picked a Toyota one up at the wreckers for a couple of bucks.
