While driving around one day, [Esko] noticed that the numbers and dials on a speedometer would be a pretty great medium for a clock build. This was his first project using a microcontroller, and with no time to lose he got his hands on the instrument cluster from a Fiat and used it to make a very unique timepiece.
The instrument cluster he chose was from a diesel Fiat Stilo, which [Esko] chose because the tachometer on the diesel version suited his timekeeping needs almost exactly. The speedometer measures almost all the way to 240 kph which works well for a 24-hour clock too. With the major part sourced, he found an Arduino clone and hit the road (figuratively speaking). A major focus of this project was getting the CAN bus signals sorted out. It helped that the Arduino clone he found had this functionality built-in (and ended up being cheaper than a real Arduino and shield) but he still had quite a bit of difficulty figuring out all of the signals.
In the end he got everything working, using a built-in servo motor in the cluster to make a “ticking” sound for seconds, and using the fuel gauge to keep track of the minutes. [Esko] also donated it to a local car museum when he finished so that others can enjoy this unique timepiece. Be sure to check out the video below to see this clock in action, and if you’re looking for other uses for instrument clusters that you might have lying around, be sure to check out this cluster used for video games.
The mechanics in dashboards are awesome, and produced at scale. That’s why our own [Adam Fabio] is able to get a hold of that type of hardware for his Analog Gauge Stepper kit. He simply adds a 3D printed needle, and a PCB to make interfacing easy.
Shame the speedo doesn’t go up to 240 km.
it does. look at the scale, the 240 is the endstop but not numbered
Both of you are right in a way :-)
The numbers don’t, but the scale itself does. There are of course better options in that regard (exactly 6000 rpm and 240 km/h marked, speeds like 150 also marked etc, for example Ford Mondeo, which is also well documented), but the ones I could source locally required analog signals to interface, which didn’t really suit my fancy. Maybe next time I’ll pick one of those and get the perfect scale. But it will also be quite a different challenge altogether. As a side note, I have a BMW cluster lying around (which I bought out of desperation when the Fiat one seemed impossible to get working), that has the correct scale and requires BOTH digital and analog signals.
Hi Esko!!! Have you complete list pids for reset interval stilo? Tks JJ
Stop me if I’m wrong, but don’t 24 hour clocks go from 0 to 23 hours, in which case this speedo is fine.
They do go above 23 for times like 23:30. But this cluster is missing 230, too. So technically it’s incomplete anyway.
The numbers are only written for even speeds (20, 40, 60 etc), but there’s a marker for 230 shown on the dial exactly like 210, 190 etc. Since the clock is digitally driven it needs only to point directly at the correct time period, not slowly increase the position of the hour hand between two points as the hour progresses.
There are clusters with “odd hours” marked, but they are much rarer. I considered ponting the hour only at the stops and not in between, but in the end decided to go with a more traditonal look.
neat, i made a similar one with a cluster from a lotus elise.
This is cool! Is yours online somewhere? I couldn’t find any when I was searching for previous projets.
I’ll dig it up, i did it around 2006, it’s more or less the same though, 1Mbps CAN with RPM/KPH. the motors are nice swiss ones
Yes, I noticed also that the motors in the BMW cluster made by VDO are virtually entirely quiet, while the ones in the Fiat one by Visteon make a loud whirring noise. But this enables me to have the ticking sound for the clock.
unfortunately this is the best pic i could find of it.
http://charliex2.files.wordpress.com/2009/08/dsc01751.jpg
Well, the digital speedometer in the lower right corner of the picture is cool, too.
aim race dash, the reason i have a bunch of those clusters spare to turn into things.
I can’t reply to your comment, so i’m replying to my own. So, if I understand correctly, you’re replacing the original dashboards with this? And also, what else have you turned these into?
also can’t reply to yours., mostly i use them for on bench ecu simulation work, or spares.
Seems like a fun job. Lucky you!
mostly a hobby now.
GREAT CLOCK! I had to alter his code to get it working. moved “void sendData” to after “void setup”
CAN BUS library download link [ http://www.ittgroup.ee/en/index.php?controller=attachment&id_attachment=7 ]
WORKING ARDUINO CODE
//~~~~~~CAN_Clock.ino~~~~~~~~~~~~~
// Esko Haas CAN BUS car dash clock
#include
#include
#define INSTRUMENT_LIGHTING_ON 0x08
#define MEAN_WATER_TEMPERATURE 130
#define WATER_TEMPERATURE_DELTA 20
#define ENGINE_SPEED_FACTOR 32
#define VEHICLE_SPEED_FACTOR 0.10625
#define SEND_INTERVAL 1000
#define HOURS_BUTTON 3 // #2 is taken by CAN-BUS shield
#define MINUTES_BUTTON 4
struct {
struct {
int hours;
int minutes;
int seconds;
int day;
int month;
int year;
} timeData;
} dataIn;
struct {
int fuelLevel;
int rpm;
union {
short value;
struct {
unsigned short low : 8;
unsigned short high : 5;
} bytes;
} speedData;
int waterTemperature;
} dataOut;
unsigned long previousSendTime;
int previousMinutes;
int waterTemperatureDelta = WATER_TEMPERATURE_DELTA;
int hoursButtonState = HIGH;
int hoursButtonLastState = HIGH;
int minutesButtonState = HIGH;
int minutesButtonLastState = HIGH;
MCP_CAN CAN(10);
void setup() {
Serial.begin(115200);
START_INIT:
if (CAN_OK == CAN.begin(CAN_50KBPS)) {
Serial.println(“CAN BUS Shield init ok!”);
}
else {
Serial.println(“CAN BUS Shield init fail”);
Serial.println(“Init CAN BUS Shield again”);
delay(100);
goto START_INIT;
}
pinMode(HOURS_BUTTON, INPUT);
digitalWrite(HOURS_BUTTON, HIGH); // inverted logic in order to use internal pull-up resistors
pinMode(MINUTES_BUTTON, INPUT);
digitalWrite(MINUTES_BUTTON, HIGH);
}
void sendData(int id, int len, …) {
va_list args;
va_start(args, len);
unsigned char data[len];
for (int i = 0; i < len; i++) {
data[i] = va_arg(args, int);
}
va_end(args);
CAN.sendMsgBuf(id, 0, len, data);
}
int fromPseudoHex(int val) {
return String(val, HEX).toInt();
}
int toPseudoHex(int val) {
return strtoul(&String(val)[0], 0, 16);
}
void loop() {
unsigned long elapsedTime = millis() – previousSendTime;
hoursButtonState = digitalRead(HOURS_BUTTON);
minutesButtonState = digitalRead(MINUTES_BUTTON);
unsigned char hoursButtonPressed = (LOW == hoursButtonState && hoursButtonLastState != hoursButtonState);
unsigned char minutesButtonPressed = (LOW == minutesButtonState && minutesButtonLastState != minutesButtonState);
if (hoursButtonPressed || minutesButtonPressed) {
if (hoursButtonPressed) {
dataIn.timeData.hours++;
if (23 < dataIn.timeData.hours) {
dataIn.timeData.hours = 0;
}
}
if (minutesButtonPressed) {
dataIn.timeData.minutes++;
if (59 elapsedTime) {
return;
}
// Serial.println(“sending data”);
waterTemperatureDelta *= -1;
if (dataIn.timeData.minutes != previousMinutes) {
dataIn.timeData.seconds = 0;
}
else {
dataIn.timeData.seconds++;
}
dataOut.fuelLevel = 100 * (60 – dataIn.timeData.seconds) / 60;
dataOut.rpm = 100 * dataIn.timeData.minutes / ENGINE_SPEED_FACTOR;
dataOut.speedData.value = 10 * (dataIn.timeData.hours + (float)dataIn.timeData.minutes / 60) / VEHICLE_SPEED_FACTOR;
dataOut.waterTemperature = MEAN_WATER_TEMPERATURE + waterTemperatureDelta;
// sendData(0x6e7, 5, 0x92, 0x32, 0x05, 0x50, 0x03); // settings
// sendData(0x6e7, 5, 0x00, 0x00, 0x00, 0x00, 0x00); // settings
sendData(0x180, 6,
00, 00, 00, 00, 00, 00
);
sendData(0x281, 8,
00, 00, 00, dataOut.waterTemperature, 00, 00, dataOut.rpm, 00
);
/*
sendData(0x286, 8,
00, 00, dataOut.speedData.bytes.high, dataOut.speedData.bytes.low, 00, 00, 00, 00
);
*/
sendData(0x2a0, 4,
dataOut.speedData.bytes.high, dataOut.speedData.bytes.low, 00, 00
);
sendData(0x380, 8,
INSTRUMENT_LIGHTING_ON, 00, 00, 00, 00, dataOut.fuelLevel, 00, 00
);
previousSendTime = millis();
previousMinutes = dataIn.timeData.minutes;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~
And that, folks, is why we have Pastebin and GitHub Gists.
Thank you! I’m actually using this library, as it causes less interrupts.
https://github.com/coryjfowler/MCP2515_lib
Looking for a cluster clock with a warning light gauge