Retro Digital Dashboard

Hello Instructables,

This is my stock appearance digital dashboard for early/pre-computer controlled cars. This includes ignition coil driven tachometer, speedometer, voltmeter, and dash lights.

What prompted me to start this was necessity. My 1970 Chevrolet Nova is a terrible mess of GM parts ranging from 1965 to about 1998. This all works great until some parts get lost in translation. The car has a T5 transmission out of a 1988 Camaro, that has been further modified with S10 parts, meaning the 1970 cable driven speedometer has nowhere to plug into. The original gear and cable drive would take significant machining and welding to line back up, making the stock speedometer not a viable option.

I have the opinion that aftermarket dashboards tend to look gaudy on mild street cars, and GPS fix units are very expensive and can be sluggish. So the goal became to retain the look of the original dashboard and add functionality.

I was shocked when I couldn't find an Instructable that had done a dashboard replacement like what I needed, so I figured it's time to get one done. After some digging around, I was pleased to find the Switec stepper library for Arduino. These are little steppers that are in modern GM dashboards, so they are a perfect way to digitize this dash.

I am writing this assuming you do not also have a 1970 Nova, but the process, code and assembly should help others with similar projects. (If you do have a third gen Nova and want more info/photos, feel free to message me!) In fact, I have been using my 1989 Toyota 4Runner, that is a computer controlled OBDI engine as a test pony.

DISCLAIMER!

In this project, we will be connecting to automotive electronics. Bad/expensive things can happen if you send 12v power down the wrong line of an ECU. This project is intended for OBDI and earlier vehicles with a distributor or other simple/archaic form of ignition. I'm not saying it won't work with anything made after 1996, but there are likely easier ways to get it done on something that new.

I am not a programmer nor an electrical engineer. However, I take constructive criticism well. If you see something I did and have a suggestion of a better way to do it, please comment! Please be gentle!

Now that that is out of the way, lets begin.

Tools used in this project:

Soldering tools

Wire strippers for small and medium AWG wire

Crimpers for connector pins and sockets and regular automotive terminals

Basic hand tools needed to take apart the dash

Laptop computer to read an Arduino in a car

Parts used on this project:

Small gauge ribbon wire and general wire

Protoboard

4-position connector kit with pins

3-position connector kit with pins

Regular automotive spade, bullet, and ring terminals

(QTY 1) Arduino Nano

(QTY 1) 7805 voltage regulator

(QTY 5) 10 kohm resistors

(QTY 3) 22 kohm resistors

(QTY 1) 330 ohm resistor

(QTY 2) 0.01uf capacitor

(QTY 1) 100v zener diode

(QTY 3) 4.7v zener diode

(QTY 1) 5.6v zener diode

(QTY 3) 14004 diodes

(QTY 1) H11L1M optocoupler

(QTY 1) inductive proximity sensor

(QTY 2) Switec x27.168 stepper motors

12v Neopixels

Double stick tape

Your favorite glue

Day-glow orange paint

Packaging plastic pulled from the trash

Hot glue

Referenced code libraries:

https://github.com/clearwater/SwitecX25

https://github.com/adafruit/Adafruit_NeoPixel

I got lucky and scored a broken dashboard that matches the one that was in the car. This one arrived with a broken speedometer, rough flexible circuit and a rusty paint-job. Perfect to modify! I would feel bad destroying a working one (and they tend to run $200+). I lucked out and the gas gauge on this unit was still functional, but I had intended to scavenge the working one from the dashboard in the car. If it ain't broke...

As you can see, GM spared no expense with this dash. A speedometer, a gas gauge, some idiot lights, and a very 60's looking dead gauge.

Naturally, the tachometer will use the dead gauge, and I will modify the original speedometer to use the stepper motor. The Neopixel dash lights are because I don't trust those old incandescent bulbs and shoddy flex circuit to still function. I can drape them across the back of the metal enclosure, and it will light the gauges.

I struggled with what to do with the odometer spot. I debated an OLED screen, but decided that would be a little much and settled for a Neopixel to indicate various things. My first attempt is a voltmeter.

Your dashboard will likely be quite different than mine, but you get the idea.

Lets start things off simple. We are hooking a 5v Arduino to a "12v" system. Cars happen to have a very nasty environment for electronics. 100v+/- spikes are possible on the regular 12v system, especially in something as old and unrefined as this car. These components need to function with inputs between 10.5v and 16v. Most cars typically will stay around 13-14v while running, so an external regulator is a must. I added a 14004 diode to prevent reverse voltage from damaging anything.

The stock dash lights were pretty dismal, and I had some 12v Neopixels left over from another project... so I figured why not?

The dash light signal is from one of the original light bulb sockets on the back of the dash. So to have the Arduino read the 12v signal on a digital pin, I used a voltage divider with 22k and 10k resistors. This takes a 12.2v battery and takes it down to 3.3v which is still enough to pull a pin high. Additionally, there is a 4.7v zener diode to bleed off any large spikes. The Neopixels are wired straight to car power and ground, and the 3rd signal wire is connected to an open digital pin on the Arduino to drive them.

Currently, the code just has them fixed to one color, and they come on with the dash switch.

Simple enough to start? And this gives me the option to RGB rainbow my dash. Nice touch, but I keep them the stock green color. Maybe I'll get more creative with them later.

Next up is the voltmeter.

The circuit is repeated from the dash light input, but this time runs to an analog input. The display is the last Neopixel in the string, which I have extended and attached where the original odometer was. Code is set up to fade the color from green to red as the voltage drops from 12.3v down to about 10v. Above 12.3v (i.e. the engine is running), the display turns off to not blind the driver. Not a real display, but better than nothing. Works as an idiot light to make you look at a gauge.

The code reads the analog input, converts it to volts, and uses the voltage reading to either increase/decrease the red and green colors on the Neopixel.

The construction is as simple as it gets: just some packaging plastic that I sharpied black and adhered to the back of the gauge. This serves to hide the lights when they are not on. The Neopixel is taped behind that in the center of the opening.

Code can be found at the end.

The speedometer circuit is essentially the same voltage divider circuit again. The main difference is that now there is an inductive proximity sensor mounted under the car which is pulsing as something on the driveshaft passes in front of it, rather than a light switch. The prox sensor gets 12v power, ground, and the output wire goes to an interrupt pin through another identical voltage divider.

The proximity sensor I have is an industrial one that someone gave me, but these are available on Amazon/Ebay for 3d printer bed leveling. The wire color coding is even the same as the one I am using, which is why the colors are included in the diagram.

I ended up putting the dash lights, voltmeter, and speedometer circuits all on the same piece of protoboard with the Arduino. This board also has all the connectors for the steppers, connector for the proximity sensor, key on power lead, and main ground lead. It ends up getting a bit hairy with all the soldered wires. I found some packaging from some craft supplies that fit the whole mess like I planned it. With an enclosure figured out I hot glu.... I mean potted around the board to keep it from vibrating off of its socket and keep the thin wires from getting pulled.

The speedometer gauge took a bit of creativity on how to mount the stepper. I ended up using some thin plastic off of some packaging to screw the stepper to the original gauge where the spring and weights used to sit. This is working very well, and I enjoy the reuse. With the original needle drilled out and crimped to the stepper, the gauge assembly is done.

The drive shaft speed sensor is a different animal. It was my intention to see if I could pick up the U joint yoke corners and just bracket the proximity sensor to the rear end. The transmission was also an option for mounting the sensor, but this joint slides back and forth with suspension travel.

The pictured mount worked temporarily until a large bump dislodged it. I have yet to get this sorted in a way that I like/is robust and reliable. I am thinking I will need to have a toothed reluctor wheel cut out and mounted to the rear end yoke.

I will admit here, unlike the rest of the parts of this dash, I have yet to drive around with the speedometer for reasons discussed in the previous step. I have only mocked the system into position, so I haven't caught any mistakes/tuned the code to be accurate. However, I have been testing the sensor/code with a Dremel spinning a metal pinwheel. It reads at least up to full sweep and gives plausible values from the input rpm.

The speedometer code functions similarly to the tachometer, but it will be much less universal. To run this you will need to calculate a value for driveshaft revolutions per mile. The info you will need includes the rear end gear ratio, tire diameter, and degrees per mph on the gauge.

Max mph: 120

Angle between 0 and max mph: 140 deg * 3 steps per deg = 420 max steps

420 max steps / 120 mph = 3.5 steps per mph

(63,360 inches / 1 mile) / (25.3 inches tire dia * pi) = 797 tire revs per mile

797 tire revs per mile * 3.08 rear end gear ratio = 2,455 driveshaft revs per mile

(360,000,000 microseconds / 1 hour) * (1 driveshaft rev / 4 pulses) = 90,000,000 microseconds driveshaft revs per hour

90,000,000 microseconds driveshaft revs per hour / 2,455 driveshaft revs per mile = 3,6659 microseconds miles per hour

36,659 microseconds miles per hour * 3.5 steps per mile per hour = 128306 microsecond steps

128306 microsecond steps / delta t between pulses microseconds = steps to display speed

The calculated number of steps is fed to the Switec library, and the motors are updated on the main loop.

There is a filter in place that only updates the motor if the calculated mph value is greater than 6 steps different from a previous update. There is also code that if enough time passes with no update it will return to zero.

On a similar note, I learned why modern cars always cycle their gauges when they start: They are homing the steppers back to zero. Ask me how I figured this out... This is in the code, too. My setup unfortunately does not have forward stops to make sweeping forward on startup a good idea. So currently the steppers groan a bit on startup as they are pushing against the home position.

I will put the code at the end, we will be talking about it more. It is quite easy to take what parts you want from it, and all the parts work independently from each other anyways.

The tachometer was by far the most involved part of this project. Typically, aftermarket tachometers are connected to the negative side of an ignition coil. The circuit shown employs an optocoupler, which is an LED with a receiver to decouple our micro-controller from the 400v spikes that occur when an ignition coil fires. Take a look at this good explanation of an ignition coil. I was always struggling to just pick up that first main ignition pulse without all the ringing. Additionally, there is a tremendous amount of electromagnetic noise that occurs around the 40,000v pulsing to the spark plugs. Protecting and filtering the noise away from the Arduino proved to be incredibly challenging. It took a lot of Googling, several attempts, and blown optocouplers to get the circuit I have now. Currently, I can only test this on my Toyota. Previous iterations of this required more resistance to filter out the noise when I tried to move from the Toyota to the HEI equipped Nova.

The two keys I have going on here are an optocoupler and a zener diode. This particular H11L1M optocoupler has a schmitt trigger that really helps clean up the signal. The 100v zener diode is blocking any smaller ripples. I have tried this circuit with 4N25 and 4N35 optocouplers and had no success.

Long of the short of it is you should test this circuit before committing anything to it. Ignition systems vary, and the noise and ringing will be different. Adjusting the input resistors and zener diode may be necessary.

Here is a link to a product that does exactly what I am doing. He has a good explanation of what his (and my) circuits are doing. He was even kind enough to share his schematics and board CAD as well. I would have tried it if I could source the components.

https://wiki.autosportlabs.com/CoilX

If I had found this first before doing all of this work, I would have just bought it. However, since I have noticed such variation between different ignition setups and struggled with different noise levels, I figured I would just continue to run what I have.

The Megasquirt community also has solutions on how to hook a micro controller to read coil negative.

This guy also has a whole sensor interface on his T bird.

The circuit I used is a combination of all of these.

With it completed, I keep it in a separate enclosure to keep the noise away from the Arduino. This enclosure happens to be from sewing needle packaging and fits rather nicely.

From there, a connector is hooked to the 4 digital pins that run the stepper, and you should be good to go.

This was pretty easy considering I had the dead gauge to work with. Assembly was as simple as drilling a small hole in the center to fit the shank of the Switec stepper. I found that double sticky tape worked pretty well to keep the stepper in place. I didn't want to use screws to hold the motor on because they would show on the face.

The needle is a small piece of packaging plastic sprayed day-glow orange with a dab of glue to make a socket for the motor. Once dry, it allows me to take the needle on and off and still has a firm grip.

The trickiest thing I did here was adding the numbers. The dead gauge had those nice 60's marks radially around it, so it made sense to use a 180 deg sweep. I was able to photo the numbers from the speedometer, Photoshop (aka Gimp) them to create a DXF file, and cut them on a vinyl cutter that a friend has access to. From there, it took careful hands and a couple of tries and curse words to put the numbers exactly where they made sense on the lines of the gauge.

I am pretty proud of the result.

The gist is the tachometer code takes the number of cylinders, the desired sweep of the gauge, the number of steps of the stepper, and the max rpm of the gauge. These are used in the equation.

My case:

Max rpm of the gauge: 6,000 rpm

Max sweep of the gauge 180 deg * 3 steps per degree

Number of cylinders: 8 meaning there are 4 coil pulses per revolution. Remember this is a 4 stroke engine.

I am using microseconds as the time measurement between pulses. So 60,000,000 microseconds per min

(540 steps / 6,000 rpm) * (60,000,000 microseconds / 1 min) * (1/4 rev elapsed between pulses) = 1,350,000 steps microseconds

1,350,000 steps microseconds / delta t between pulses microseconds = steps to display rpm

The same filter is in place so a value must be greater than 6 steps from the previous update to change the update, and there is the same zero timer.

I will put the code at the end.

So here it is, awaiting installation into its final home... (long story, but I cannot reach where the Nova is stored right now) inviting more scope creep. Also, here is the promised final schematic combining all four features and code. To compile the code, you will need the libraries I have included in the supplies of this Instructable.

Once I can get all of this sorted into its home and work the gremlins out, I am thinking of adding to the middle voltage indicator for other things like a shift light. Another idea would be to take the original dimmer switch and use that to adjust the color or brightness of the dash lights.

Thanks for reading.