Team V8 Renegades: Benjamin Furlong, Taylor Gartland

Published November 27, 2016

Engine & Transmission Temperature Gauges on a Budget

Don't spend hundreds of dollars on aftermarket temperature sensors or rely on a fake gauge ever again!

BeginnerFull instructions provided2.5 hours1,680

Engine & Transmission Temperature Gauges on a Budget

Things used in this project

Hardware components

Particle Photon

Temperature Sensor

Waterproof, 2m, http://a.co/jezaC9W

Jumper wires (generic)

Resistor 4.75k ohm

Resistor 221 ohm

3 mm LED: Red

3 mm LED: Green

Breadboard (generic)

USB-A to Micro-USB Cable

Hand tools and fabrication machines

Soldering iron (generic)

Soldered Wires to each of the ends of the temp sensors and covered with electrical tape.

QuikSteel

Used to hold sensors to the transmission and engine oil pan.

Story

Owning a racecar isn't easy....

2000 Chevrolet Camaro Z/28, aka racecar

One of the most important things to know about a performance car (or any car really) is the temperature of the various driveline components. Things you'd want to know the temperature of are the engine oil, coolant, transmission, and differential. The ones that matter the most though are the engine oil and transmission, as these are the most expensive and important parts of the car's performance.

Unfortunately, most manufacturers don't put these vital temperature measurements into the gauge cluster for the driver to see. On most cars, you'll only get a coolant temperature gauge, which doesn't accurately reflect the real temperatures of the engine or transmission. Not only that, but many of these gauges are also fake! Because temperature can easily fluctuate, manufacturers program the temperature gauges to react a certain way. Usually they increase at a set pace on warm up, just hover around the middle while driving, and then start increasing even more if there is an overheating condition. Basically, they're only there to tell you if your car is overheating by a dangerous amount.

Temp gauge in my Camaro. It is fake and just hovers around 210, even though I have a 160 degree thermostat.

Even worse, aftermarket temperature gauges and sensors can cost hundreds of dollars and may require extensive wiring and modification. Here's a popular brand's cost for the aftermarket temperature gauge and sensor that I would need for my car, and it only has one sensor, meaning it can only measure one component at a time.

You'll also need a gauge cluster mount.

Luckily, the Particle Photon has come to the rescue! With simply two Particle Photons ($40), some long one-wire temperature sensors ($16 for 5), and some QuikSteel ($5) you can have a fully functional temperature monitoring system for a fraction of the price!

Set-Up

To set up this project, you'll need everything in my hardware list along with a power source (most likely a cigarette lighter adapter). Use the codes provided (read through them to make the necessary additions and changes you'll need) and the schematics to build the circuits. Since the wires coming from the temperature sensor are fragile and fibrous, I soldered them to some stronger wires and used electrical tape to insulate the wires.

In order to set up the temperature sensors, you're also going to need access under the car or into the engine bay and a way to transfer the wires back into the cabin. On my car it was as simple as removing the center console, running the wires through the rubber insulator on the gear shift, and then they were outside. I then used a product called "SteelStik" to attach the sensors to the (cleaned) sides of the oil pan and bellhousing. SteelStik sets quickly, but it's best to give it several hours. All you do is cut the amount you want, kneed it up with your fingers, and attach the sensor with it. Once it had set for about an hour, I pulled the wires up into the cabin and made sure they weren't hanging down too much. If you have issues, zip ties and duct tape are your friend.

Once inside, you can hook-up the sensors to the particles and maneuver/tuck the wires how you please so that they're as unintrusive as possible. Just a heads up, this is the part where having a wi-fi hotspot car or transmitter is useful, if you don't have that you can enable your phone to be a hotspot. Don't worry, this temperature data doesn't update often and only uses a very small amount of data. Set your particles up to use this hot-spot and bring your laptop with you to flash them once you're done.

Before I tucked up everything. Hint: The back of the breadboards have sticky sides on them.

Demonstration & Results

I took about a 30 minute drive onto the highway with the particles. What I found out is that the particles take a little while to reach equilibrium with the real temperatures of the engine and transmission. So for me, when both the engine and transmission were consistently above 110 F they were warmed up. It might be different for your car and how good of a measuring point you have. The transmission took some time because I had to sit a stoplight for a little while in the beginning and I wasn't able to travel very fast until about 15 minutes in. The measurements lagged a bit behind the real temperatures, but that's to be expected with surface measurement and cooling airflow underneath the car.

Overall if I had to give some hindsight advice, using an IR thermometer after a long drive and finding the hottest points prior to mounting the sensors might improve the rate of heat transfer. I knew those areas were warm from feel experience, but it's possible they weren't the warmest areas. In addition, while I did use the Particle app itself to log temp data, using If This Then That (IFTTT) to automatically record the data would be easier.

Code

void setup() 
//These pinModes are for the LED's. You can change them as you wish.
{ 
pinMode(D0, OUTPUT);
pinMode(D7, OUTPUT);
pinMode(D2, OUTPUT);
Particle.subscribe("insert_your_event_here", myHandler);
}
void loop () {
    
}
//atoi converts the data back into temperature. The program works by
//taking temp measurements and comparing it to turn on or off LED's.
//Change the temp vlaues as you desire.
//We've found that both the engine and transmission have usually warmed up
//By the time that both have hit 110 deg. Keep in mind that the sensors are
//on the outside and both air cooling and rate of heat transfer are considered.
void myHandler(const char *event, const char *data) {
   int num = atoi(data);
   if(num<=110) {
      digitalWrite(D7,HIGH);
      digitalWrite(D0,LOW);
      digitalWrite(D2,LOW);
  }
  else if(num>110 && num<210) {
      digitalWrite(D2,LOW);
      digitalWrite(D0,HIGH);
      digitalWrite(D7,LOW);
  }
  else {
      digitalWrite(D7,LOW);
      digitalWrite(D0,LOW);
      digitalWrite(D2,HIGH);
  }
}

//Go to Libaries, OneWire, and DS18x20_Temperature.ino.
//Then Click add to app to add it to this code FIRST.
//Otherwise, this code is nearly identical to the code
//found on the Particle Tutorial for temperature Logging.
#include "OneWire/OneWire.h"
 
OneWire ds = OneWire(D4);

unsigned long lastUpdate = 0;

void setup() {
  Serial.begin(9600);
  pinMode(D3, OUTPUT);
  pinMode(D5, OUTPUT);
  digitalWrite(D3, LOW);
  digitalWrite(D5, HIGH);
}


void loop(void) {
  byte i;
  byte present = 0;
  byte type_s;
  byte data[12];
  byte addr[8];
  float celsius, fahrenheit;

  if ( !ds.search(addr)) {
    Serial.println("No more addresses.");
    Serial.println();
    ds.reset_search();
    delay(250);
    return;
  }

  Serial.print("ROM =");
  for( i = 0; i < 8; i++) {
    Serial.write(' ');
    Serial.print(addr[i], HEX);
  }

  if (OneWire::crc8(addr, 7) != addr[7]) {
      Serial.println("CRC is not valid!");
      return;
  }
  Serial.println();

  switch (addr[0]) {
    case 0x10:
      Serial.println("  Chip = DS1820/DS18S20");
      type_s = 1;
      break;
    case 0x28:
      Serial.println("  Chip = DS18B20");
      type_s = 0;
      break;
    case 0x22:
      Serial.println("  Chip = DS1822");
      type_s = 0;
      break;
    case 0x26:
      Serial.println("  Chip = DS2438");
      type_s = 2;
      break;
    default:
      Serial.println("Unknown device type.");
      return;
  }


  ds.reset();               
  ds.select(addr);          
  ds.write(0x44, 0);       


  delay(1000);     
  

  present = ds.reset();
  ds.select(addr);
  ds.write(0xB8,0);         
  ds.write(0x00,0);         


  present = ds.reset();
  ds.select(addr);
  ds.write(0xBE,0);         
  if (type_s == 2) {
    ds.write(0x00,0);       
  }


  Serial.print("  Data = ");
  Serial.print(present, HEX);
  Serial.print(" ");
  for ( i = 0; i < 9; i++) {          
    data[i] = ds.read();
    Serial.print(data[i], HEX);
    Serial.print(" ");
  }
  Serial.print(" CRC=");
  Serial.print(OneWire::crc8(data, 8), HEX);
  Serial.println();


  int16_t raw = (data[1] << 8) | data[0];
  if (type_s == 2) raw = (data[2] << 8) | data[1];
  byte cfg = (data[4] & 0x60);

  switch (type_s) {
    case 1:
      raw = raw << 3; 
      if (data[7] == 0x10) {
        raw = (raw & 0xFFF0) + 12 - data[6];
      }
      celsius = (float)raw * 0.0625;
      break;
    case 0:
      if (cfg == 0x00) raw = raw & ~7;  
      if (cfg == 0x20) raw = raw & ~3; 
      if (cfg == 0x40) raw = raw & ~1; 
      celsius = (float)raw * 0.0625;
      break;

    case 2:
      data[1] = (data[1] >> 3) & 0x1f;
      if (data[2] > 127) {
        celsius = (float)data[2] - ((float)data[1] * .03125);
      }else{
        celsius = (float)data[2] + ((float)data[1] * .03125);
      }
  }

  fahrenheit = celsius * 1.8 + 32.0;
  Serial.print("  Temperature = ");
  Serial.print(celsius);
  Serial.print(" Celsius, ");
  Serial.print(fahrenheit);
  Serial.println(" Fahrenheit");

//This is really all you need to play around with here. Just name it what you want and change the delay (in miliseconds)
//for recording. Remember only one sensor is read per delay cycle, so take that into account.
  String temperature = String(fahrenheit); 
  Particle.publish("insert_your_event_here", temperature, PUBLIC); 
  delay(15000); 
}

Credits

Benjamin Furlong

1 project • 1 follower

UNCC 2018

Taylor Gartland

1 project • 1 follower

Thanks to Particle and Ric DelMar.

Engine & Transmission Temperature Gauges on a Budget