On my journey to restore a Renault 4 F6 for the 4LTrophy rallye, I decided to shove some microcontrollers under the hood to enhance the driving and user experience.
I didn't design the OtBC to work with any old-timer, as it is specifically designed to work with a R4 (because of the sensors and features I personally want to add), although the codes and schematics should not be too hard to adapt to any car brand and model if you know what you're doing ;)
This is the board computer that controls all the lights, and monitors the different engine fault sensors. Now you may wonder why I’m going through an Arduino just to control lights with a simple switch, and there is no real reason why I’m doing so, other than custom functionalities ! For example, I can precisely control the blink rate of the turn lights (which you should definitely use when turning BTW), or I can put a « Master test switch » to turn all of the lights on for visual inspection.
But, of course, it has to be very reliable; I don’t think it would be pleasant is my headlights turn off randomly at night while I’m driving because I forgot to break a loop... So there’s a lot of thorough testing going on !
You may have noticed a small 128x64 OLED screen embedded; This screen, when everything is OK (e.g. when there’s no fault sensor triggered), displays useful information like engine RPM, cooling fluid temperature, and GPS Speed&Heading from GPC02.
I made a hole in the original dashboard, and printed a little fame to make it look nicer :
This display also gives detailed error messages when a sensor is triggered. Here are the different logos I made for it :
Those where drawn in Adobe Photoshop pixel by pixel, and converted to c++ arrays with LCDAssistant.exe, so I didn’t have to convert by hand all 8192 pixels of some logos.
As you can see, there are 128x64 (shrunken down to 64x32 above), 32x32, 16x32, 16x16, and even 16x8/8x16 logos.
The only 128x64 logo is for the "ERROR 501" screen; this one shouldn't ever show up, unless I did something wrong in my display routine and the display I'm trying to, well, display, doesn't exist.
The 32x32 logos are on the upper row : battery, handbrake, low brake fluid and choke.
The 16x32 and 16x16 logos are on the second row : km/h (speed), cooling circuit temp, low oil pressure (16x32), compass (heading) and engine RPM.
Now the 8x16 and 16x8 logos; those are actually the "P" and "Genie lamp" logo inside the bigger 32x32 brake logo. In order to save on code space, when the Arduino has to draw the "handbrake" or "low brake fluid" logo, it first draws the background (e.g. the circle with two parenthesises (32x32)), then in the middle of that the "P" or "Genie lamp", whichever is needed. This means that I only need to store one 32x32 logo array, and two smaller 16x8/8x16 logo arrays (every saved byte counts !).
All the original light bulbs where replaced with white LEDs with 3D Printed PETG diffusers. Each LEDs is controlled by an individual pin on the Arduino Due. You may also notice a white and a blue cable, right above a 6pin connector; the two wires are for the speed gauge backlight, and the 6p connector is for the OLED screen and the piezo speaker. The piezo was put right there so I can actually hear it above all the engine noise.
• I removed all the original wiring harnesses, and just put back the necessary wires to start and run the engine. Here I'm also testing a prototype of a ZVS Flyback ignition coil system (log coming soon) : YouTube link
Just to clarify, the board computer here does not control the engine, steering or brakes (not even the brake lights), as I do not have the skills to certify my own work to automotive standards, plus some aspects of such modifications would be illegal in my zone of jurisdiction.
That said, here is the block diagram of the elements of the OtBC :
As you can see, there are three GPCs that communicate with each other via a RS485 bus. GPC01 and 02 are based on an Arduino Due, and GPC03 on an Arduino Uno or Mega (I'm not sure yet as dev has not begun on this one).
I'm splitting the board computer in three parts for safety and coding convenience : every GPC can work on their own, but they can share values (like engine RPM from GPC01, GPS speed from GPC02, etc.), plus I can probe the RS485 bus with a computer with an Ad Hoc interface.
GPC01 is used for the vital functions : lights, dash lamps and warnings. Its code has to be lightweight and reliable. I'm not adding too many bells and whistles to it, and I'm intensively testing it as a crash would inevitably disable all the lighting of the car, which is not a good thing while driving.
The code works by multithreading the Arduino Due with the Scheduler library. I've already used this lib, and when used carefully it is really reliable.
There are threads that read the switches states ans sets flags if on, and other threads that read the flags and sets the outputs high or low. Why go through flags ? Well, it's easier to debug, to force a state, and to manipulate in other parts of the code; for example, I do not have to call the "digitalRead()" function (which can slow down the code considerably) every time I want to know the state of something. TL;DR: Reading a boolean is faster than calling a "digitalRead()" function every time.
[GPC02 schematic block image placeholder]
GPC02 is used for multimedia and environmental awareness (fancy words for "It knows the temperature and GPS data" amongst other things). The multimedia aspect of this GPC consists of an Audio block with an fm radio module and a bluecoats receiver etc., and a rudimental navigation system (= on screen compass). It also has an audio module which reads MP3 files from an SD card; this is used to playback recording alert messages, when a problem appears (for example, a voice will say "Warning, engine overheating", when the engine overheating sensor triggers). [this section will get more detailed as the dev of GPC02 continues].
[GPC03 schematic block image placeholder]
GPC03 doesn't really control anything, it's more of a RS485 sniffer that displays the data on rotary indicator gauges. As the dev of GPC03 has not yet begun, I don't really have to say anything yet, so this section will change when the dev has begun.
The whole reason I'm doing this is because I want to participate to the 4LTrophy (wiki), in which each crew has to bring school supplies on board of a Renault 4 from Biarritz France to schools in Fez Morocco (and other schools along the road).
The variant of 4L I have is the 4L F6, which is the longer van model. It has a 1108cm³ 4-cylinder gasoline engine (with a power output of 47hp), and a manual 4+1 speeds transmission box with a Front Mid-engine, Front-wheel-drive layout. It has no power steering or power brakes, but it doesn't need to as the whole car only weighs 750 kg (1,653 lb).
I'm not going to cover the chassis restauration on mine in detail here, as the project is dedicated to the board computer I'm building for it (I may probably still make one project log dedicated to only that though).