Make your own custom racing dashboard for a more immersive experience in your next computer-based car game, at a fraction of the cost of commercial units.

BUILD TIME: 4 Hours
DIFFICULTY RATING: Intermediate

Simulation racing, while a niche category of gaming, is enjoyed greatly by its enthusiasts. The ability to access very expensive and high-performance cars virtually for barely a fraction of the cost of the real thing is the reason why so many flock to the hobby. Together with online multiplayer, realistic physics, and weather effects, it’s easy to see why this genre of gaming continues to entertain its enthusiasts ever since the earliest gaming consoles!

While simulation racing hardware is usually cheaper compared to its real-life equivalents, it’s no secret that its costs add up quickly. Enthusiasts frequently spend thousands on direct-drive simulation steering wheels, load-cell powered racing pedals, and even racing gloves to enhance their immersion as much as possible.

Luckily, because sim racers do not need to worry about rules and regulations, lightweight equipment, and meticulous fabrication of components like real racing teams, enthusiasts who are handy with a soldering iron and a 3D printer can put together some seriously awesome-looking (and functioning) immersive equipment. And that is exactly what we’re going to be doing in this project – at a price that won’t break the bank.

THE BROAD OVERVIEW

The reason why we’ve chosen to build a racing dashboard for this project is because of the convenience it provides to sim racers. Most racers typically have the functions of their cars bound to buttons on the keyboard – such as windscreen wipers, horn, in-car tuning, and headlights. This is often frustrating because the positions and functions of items on the keyboard must be recalled very quickly during a race. By providing a selection of programmable buttons, it’s super easy to enable or disable car functions within a well laid out control panel.

Aside from providing input functionality, we also want to display critical information about the car using lights and gauges. We’ve chosen current gear, RPM, and a shift light bar to display on our dashboard as these are critical pieces of information that a sim racer needs to know constantly during play. It’s important to note there is not much use in this display being incredibly detailed in its information, because this display is primarily going to be used in the user’s peripheral vision – there is just not enough time for tiny text on displays to be read.

Ultimately, we want to show how makers can build a racing dashboard, compatible with a huge variety of computer games, which both looks and works great! You don’t even have to be interested in purely racing games – other simulation categories such as flight, locomotive, trucking, farming, and off-roading simulators can also be added to this project with the necessary software.

How It Works

The dashboard we’ve chosen to make consists of two separate categories of electronics – one for controlling the dashboard’s user inputs – and one for controlling the display components itself. The user inputs are simpler than the display circuitry, as it is controlled by a single generic USB board, as discussed below. The display components, consisting of a tachometer, a gear display, and a shift meter, are all controlled by an Arduino Nano or Uno running the free SimHub software sketch.

In this part 1, we’ll be looking at the hardware and dashboard construction part of the display, putting together and mounting all of our parts. In part 2, we’ll get to wiring everything up and showing you how to add the free SimHub software to the project.

The Button Panel

For controlling the inputs on our button panel, we’re going to be using a Zero Delay Joystick Encoder board from Jaycar. This very common board is often found used in Raspberry Pi-base arcade machines, like our Retro Gaming Arcade Machine in Issue 30. However, since it encodes the digital inputs we connect to the unit to a USB output, we can simply hook it up to our computer and treat the joystick as any other game controller.

In our dashboard, we’re going to use eight momentary buttons and Jaycar’s SP0774 ignition panel with a missile-style ignition switch and ‘Engine Start’ button. We'll also add a momentary up/down switch for in-car tuning. This leaves us with a total of twelve digital inputs to the project, which should be plenty to control all of the utility functions of our car.

From there, it is just a matter of assigning each button on the dashboard to specific functionality in your favourite racing games.

Tachometer Gauge

The most eye-catching part of the display board, the tachometer gauge, displays the current Revolutions Per Minute (RPM) of the car being driven. This is important for racing since the RPM at which the car is being driven greatly influences its power characteristics, so the driver needs to change gears at an appropriate time to continue power delivery.

For our project, we sourced a marine tachometer with a mounting diameter of 85mm from Road Tech Marine. Both marine and automotive tachometers will work for this project, but you may need to tweak how the signal is provided to the unit – we only chose a marine tachometer because it was a part we already had available locally.

Note: The 288078 SAAS Tacho Gauge from Supercheap Auto may be suitable, however, we haven’t tested this.

The wiring method for the tachometer can be applied to most other gauges available on the internet. Aside from the 12V and Ground wires, there is typically a signal and backlight wire available for hooking into the car – or in our case, our racing dashboard. Since these tachometers report - in the most fundamental sense – frequency of rotation, it should come as no surprise that these tachometers will output an RPM proportional to the frequency of the signal provided. We will talk more about this in the fundamental build section.

The backlight wire controls whether the gauge backlight is enabled – in a real car, this would be wired to the headlight circuits for nighttime illumination. However, we’re going to wire this directly to our 12V rail so it’s constantly enabled.

Gear Display

For this project, we wanted to use a large 7-segment LED digit for displaying the current gear. This has to be quite large since we need the user to be able to identify which gear the car is in without averting gaze from the nearby monitor. A 7-segment works quite well for most racing simulators as it supports the display of pretty much any gear or car mode we will use: Reverse (R), Neutral (N), Pit (P or L), and gears 1 up to 9. This display will obviously not be sufficient for simulators where the vehicle driven has more than 9 forward gears, such as trucking simulators where 18 gears are fairly common.

As you’ll see in the fundamental build section, we came across some roadblocks when trying to use these larger displays with 5V electronics. While we did have to order a slightly different version, the dimensions should be identical so it’s a job as simple as swapping them out.

Shift Lights

If you’ve ever seen onboard video footage of an F1 car, you’ll notice on the top of the steering is a line of LEDs lighting up corresponding to the engine’s RPM. Depending on the colour of these LEDs, drivers know exactly when to change gears as the revs climb.

We’re adding shift lights to our dashboard, and for this project, we’re using a strip of very bright WS2812B RGB LEDs. Since these LEDs are addressable, individual LEDs can be changed to a specific brightness and colour. The SimHub software we’ll use in the next part of this project has a variety of different code implementations for controlling these LEDs.

If you’re building your own dashboard, you can use however many LEDs you like for your shift meter. We’re using 16, which provides a reasonable size display with four divisible segments of four LEDs. Keep in mind that these WS2812B LEDs can build current requirements very quickly the more you add. If you add any more than around what we are using, you will need to use a dedicated 5V supply to keep things running smoothly.

Note: We won’t be testing these LEDs in this part of the project. This will be described in part 2, next month.

Ignition Panel and Buttons

To really tie together the immersion of this project, we wanted some tactile buttons to add both functionality and aesthetics to our dashboard.

To give an awesome, tactile feel to the process of starting our simulated racing experience, we chose the SP0774 Racing Ignition Switch Panel from Jaycar. It includes a covered missile switch for the car’s ignition with a LED status light, and a big red button that starts the engine. The carbon fibre finish and red theme makes our simulation racing setup run faster, obviously! It also includes self-tapping mounting screws so it’s super simple to drop into a dashboard panel.

Alternatively, you could use an ignition key barrel to start up the engine. Just like a real car, you need to insert the key, twist once to start the ignition, and again to start the engine. As an added bonus, it stops anyone who doesn’t have the key from using your sim racing setup!

For our dashboard, we are adding eight momentary pushbuttons and a momentary switch in a 3x3 grid. The eight momentary buttons we are using are all Single Pole, Single Throw (SPST) so the two positions are either disconnecting or connecting its two contacts. Our tuning switch is Momentary-OFF-Momentary style, which means that the switch effectively acts as two buttons depending on the direction pushed. This could be used to raise or lower certain car settings during racing like ABS strength, turbo pressure, or engine braking.

We want to clarify that you don’t have to use the number, arrangement, or style of buttons we are using! If there is a specific type of interface style you want for your simulator, go ahead and purchase that specific style of pushbuttons or switches. There are many retailers online that also offer labelled automotive buttons for functions such as headlights, horns, and wipers, so shop about!

The only real requirement that you need to keep in mind is that the buttons you source are both Momentary and Normally Open, so they only connect their terminals when the button is pressed and do not toggle between on and off. Saying that, if the game you are looking to play with your simulator has certain functionality such as needing to hold a specific key for an extended period, you could pick up a toggle (ON/OFF) button or a switch to leave the input on whenever it is enabled.

All of these buttons are connected to a Joystick Encoder board, which can be plugged directly into a USB port and will encode any pressed buttons into joystick inputs.

This board is very common and includes support for up to 12 buttons, plus a Left/Right/Up/Down joystick. For our project, we’ll be using our 8 pushbuttons, our ignition/start inputs and our momentary up/down switch, totalling 12 buttons.

Windows includes the driver for this encoder, so it’s simply a matter of plugging the board in, opening up your favourite racing game and assigning functions to the buttons on the dashboard. There isn’t any fixed functionality of buttons on the dashboard - from a software standpoint, all buttons are just numbered inputs that can be bound to any joystick function in any game.

That’s why we won’t be labelling our buttons on our dashboard, since their functionality will most likely vary between simulation programs.

IMPORTANT NOTE: The joystick board we’re using essentially tells the operating system to treat our buttons as a physical game controller.

The Fundamental Build:

Our build will primarily consist of testing our hardware individually to ensure that the circuitry we plan to use for the final build will be adequate for the project. As we’ve discussed in the How It Works section, we’ll be using the software SimHub to drive our final build. However, for our fundamental build, we’ll write our own Arduino code to both confirm our electronics are functioning as expected and to explore how to interface with the hardware. We are also not testing our joystick board or our RGB shift lights here, as the more software-based nature of these parts will be implemented in Part 2.

Driving The Tachometer

Our marine tachometer has five wires, which according to the rear of the unit are wired as follows:

Notice that black isn’t actually the ground wire for this tachometer, which is instead the signal wire controlling the current needle position. After connecting the rather misleading ground wire and red wire to a 12V power supply, we connected the black signal wire to digital pin 9 on our Arduino Uno.

If you would like to use the backlight, connect the backlight wire(s) on your tachometer to your 12V rail. Normally, this is connected to the headlight circuitry in your car so that the dashboard is backlit when the headlights are turned on. We want it to be enabled constantly, so we connected it to 12V, but you could add a switch to enable it if your headlights are on. Our tachometer includes two backlight wires, one for a red backlight and one for an orange – we chose red.

Before we fully build the dashboard and use SimHub to drive our tachometer, we want to use our own code to verify that the unit works as expected. The way we drive this tachometer is by feeding a variable frequency signal to the black signal wire. If we feed a signal of 50Hz, the tachometer will move to the 50% position, which is 4000RPM. If we feed a signal of 100Hz, it will move to the maximum reading of 8000RPM. Note that there are different methods of driving these meters, since many are connected directly to the ignition circuitry of real cars and thus their readings can vary depending on the cylinder count of the engine. In any case, the tachometer that you do end up sourcing should respond to changes in frequency, and you may have to adjust your code accordingly. SimHub includes parameters to help calibrate and accurately drive your tachometer, which we will discuss in Part 2 of this project.

The Arduino IDE includes a very handy method that can output frequencies suitable for our tachometer: The tone() function. To allow us to input our custom frequency, we first wrote a simple Serial reader to receive integers from the Serial console.

void setup() {
  pinMode(9, OUTPUT);
  Serial.begin(9600);
}
int last_sig = 0;
void loop() {
  if (Serial.available() > 0) {
    String incoming = Serial.readStringUntil('n');
    last_sig = incoming.toInt();
  }
  tach_speed(last_sig);
}

If there are available characters in the Serial buffer, we continue to read the entire buffer until we meet the end of line character. Since we should be only transmitting integer values over the Serial console, we won’t worry about any input filtering here. We can now call our tach_speed function, which uses the tone function:

void tach_speed(int speed) {
  tone(9, speed);
}

Pretty simple, right? After we uploaded it to our Arduino, we found this works fairly well for values above 2500RPM or so. However, below that, the tachometer acts unreliably and tends to output values that aren’t at all correlated to the value we input to the code. This isn’t the fault of the tachometer unit, the tone() function of the Arduino is not actually capable of outputting frequencies lower than 31Hz. The internal hardware timers of the Arduino chips cannot output these low frequencies. If an 8MHz microcontroller is used, we can output frequencies less than 16Hz, but this isn’t much help for RPM signals below 1300RPM – so it doesn’t fix the entirety of the problem.

The next solution we tried to fix the shortcomings of the tone function was to use a software-based implementation of timing code. If we had to implement very high frequencies with software-based timing code, we’d run into hardware limitations pretty quickly, but since our frequency range is less than 100Hz for our meter, we can accomplish this software-based method with minimal trouble.

We aren’t showing the code here because we didn't use it after all, but it relies on using the Arduino’s delay() function to correctly time the duration between consecutive HIGH and LOW signals. While this method did work, there were some frustrating issues with the code. First off, the code was blocking, meaning that the delays involved in driving the frequency signal prevent any other code from running at the same time. The fact that other code also must execute between the controlled delays also means that the delays are not exact, leading to some slight accuracy offsets in the tachometer. For instance, the 80% needle position was being read closer to 83%.

To fix this, we used a non-blocking code implementation that relies rather on the millis() function of the Arduino. As the code is constantly executed, we check whether we need to change the state of the signal pin. You can see the code we chose to use.

int last_sig = 0;
void loop() {
  if (Serial.available() > 0) {
    String incoming = Serial.readStringUntil('n');
    last_sig = incoming.toFloat();
  }
  tach_speed(last_sig);
}
void tach_speed(float frequency) {
  int period = 0; 
  if(frequency == 0) {
    period = 1000;
  } else {
    period = 1000 / frequency;
  }
  int progress =  millis() % period;
  digitalWrite(9, progress > (period / 2)); 
}

Upon testing, this code works very well! The tachometer can display virtually any values given to the Arduino by the Serial monitor. One slight downside we did find with this particular tachometer is the poor responsiveness of the needle – this can be attributed to its design for marine applications. Boat engines do not quickly fluctuate in RPM unlike race car engines, so the display favours smooth needle movement over fast responsiveness. Selecting a needle position of 25% (2000RPM) and then changing quickly to a high reading – 7000RPM for example – takes a second or two to update, but the resulting position is very accurate.

7-Segment Gear Display

During our experimentation, we first tried to use Jaycar’s ZD1850 Super Large 7-segment display. This display is known as a Common Anode digit, which essentially means all of the anodes (positive side) of the LEDs are connected together. To drive it, we need a high-side current driver, providing a voltage at the cathode (negative side) to enable each segment.

The software we are using, which we will discuss more in the second half of the project, only includes support for two chips to drive the 7-segment display. Although we could hack the software’s included Arduino sketch to implement custom hardware and chips, we want to keep this simple in terms of software requirements. Our two options are the SN74HC595 and the TPIC6C595N.

We first looked at the SN74HC595, a very common shift register primarily for low-current logic applications. How a shift register works and what it can be used for isn’t the focus of the project, and thus won’t be covered here, but essentially it allows the SimHub software to manage the seven separate segments of our display with just three microcontroller digital pins. While this shift register works fairly well for lower-current (and usually smaller size) displays, where only a maximum of 20-30mA is required from the register, for our larger display it is not really applicable. Each segment of our display needs around 20mA to light at a reasonable brightness, and so, if we were to request the register display a number with a large segment count such as 8 or 0, we would very quickly reach the current limit of this chip.

We then looked at the alternative offered by the SimHub software, the 6C595N. Since it is made by multiple manufacturers, there are often different prefixes to the chip name, despite accomplishing the same functionality. Since it is readily available on Australian electronics wholesalers such as Element14, we went with the Texas Instruments TPIC6C595N. This chip, being another 8-bit shift register, works on the same principle as the SN74HC595 IC discussed above. However, this chip has been purposely designed to drive LED displays with much more reasonable current requirements due to its eight current sinks, each capable of 100mA! Unfortunately, this chip is a low-side current driver, which means it is incompatible with our common anode display.

However, the most significant issue arises from the very high forward voltage of the display. Notice that the internal schematic of the display shows that all segments consist of four LEDs in series (aside from the decimal point, which has two). Because each LED has a voltage drop of around 2V when supplying 20mA through them, that means that we need a minimum voltage of 8V to allow the display to illuminate – not including current-limiting resistors! This is frustrating because the 5V the Arduino and related hardware we are using for this project is not able to even come close to lighting up the display.

To test that the project would work with a 12V line applied to the display, we set up a test circuit. We applied twelve volts to one end of a 200Ω resistor, and the other end to a pin of the 7-segment display. We connected the two common anode pins to ground. Sure enough, very close to 20mA was flowing, the exact amount of current we needed to properly illuminate the display. This 200Ω provides a 4V drop at 12V at our required current, leaving 8V to overcome the four 2V LED forward voltages.

Now that we’ve figured out an appropriate method to drive the display, we’ve ordered a common cathode version of the display and a TPIC6C595N chip from Element14, which we will discuss more and construct in Part 2 of this project in the Main Build. A full schematic and wiring guide will be provided in Part 2 with the new parts.

The Main Build (Part 1):

Selecting the material

There is a huge variety of materials that could be used for the main dashboard panel of the project. We’ve chosen 3mm MDF for its versatility and ease of cutting into any shape. If you’re not a fan of its poor rigidity or tendency to split and break off, why not use a different material? Thin plywood, 3mm acrylic, or even aluminium will work for this project provided you have the correct tools and equipment to cut out the component holes accurately and safely in the dashboard. We encourage you to get creative and select your preferred look for the project.

To cover up the rather unsightly fibre finish of MDF, we’re using a carbon fibre vinyl to add a sleek finish to the dashboard.

* Quantity shown, may be sold in packs. ^ These LEDs have a waterproofed casing unlike the LEDs used in this project. It may impact LED spacing.

# These exact buttons are not required to fit our template. Any momentary pushbuttons with a mounting diameter of 12mm will work.

Dashboard Template

To make constructing this project easier, we’ve provided a PDF template and Adobe Illustrator file that can be printed out and stuck to your material of choice. From there, we simply have to cut out the required shapes and mount our components. To print from either PDF or Adobe Illustrator, ensure you export at 100% scale and verify the dimensions are correct by using a ruler to check the included dimensions. If you have a printer that cannot print the entire document at once – considering it is bigger than A4 – you will have to print two sections and fix them together with tape, as we did. We then used a glue stick to mount it to the MDF sheet – don’t go crazy with the applied glue, because you’ll need to take it off later!

Alternatively, if you have access to a laser cutter, we’ve provided an Adobe Illustrator file that is ready to be printed in RGB format. It includes red line vectors with widths of 0.001pt , which can be exported directly from Illustrator – which lets you skip straight to adding the vinyl and mounting the components!

Note: You may notice that the template we’re using in this tutorial is different to the one provided in the project files. As we continued with the project build, we noticed various shortcomings with the template we first designed. We’ve added some text notes, dimensions and centre-point drill markings to help you use the template more accurately, and with less fussing around getting exact dimensions.

Cutting the dashboard panel

To start our final build of this project, we’re going to be cutting out our dashboard panel from our 600mm x 900mm sheet of MDF. After sticking the template to the sheet, grab a hand saw or jigsaw and cut straight lines through the outline of the template. They should be as square as possible so other measurements are not offset. This step can actually be done before sticking the template to the panel if you find the saw blade keeps kicking the template off the MDF. To cut out the upper curved edges of the dashboard, we suggest either using a jigsaw or repeatedly cutting chips from the outline until the edges are small enough to sand.

Jigsaw Holes

To make enough space to fit our tachometer, we’re cutting out an 85mm circle. There are a couple of ways of accomplishing this large diameter, but we’ve chosen to use a drill bit and jigsaw to accurately cut out the circle in the shape of the dashboard template. Using a drill bit big enough to fit the width of your jigsaw blade, drill a hole near the edge of the circle. Then, work outwards with the jigsaw to meet the circle outline and finally follow it around the entire outline. Be very careful using these power tools, as a very fast reciprocating blade - such as in a jigsaw - is capable of causing some serious injury.

Bear in mind that the circle cut does not need to be exactly uniform, considering that the large bevel of the tachometer will cover all imperfections in our cutting job. Test that the tachometer fits well into the hole we cut by unscrewing its other securing ring and fitting it through the hole. The rubber seal should provide a solid fit once the ring is added back onto the tachometer.

After the tachometer hole is cut out, we can then work on cutting out the holes for the gear display and the ignition panel. Cutting square outlines with a jigsaw is more difficult than a circle one, so we suggest planning out how you will cut out the entire outline. You may need to cut diagonally to provide an entry point to fully cut the corner. It’s worth erring on the side of caution and cutting slightly short on your dimensions, especially the components we’re choosing to press-fit such as the gear display – you can always file or sand these edges down later. Note that the ignition panel has a slightly protruding button mount on its back side, so it is worth doing frequent test fits when cutting it out to ensure it fits snugly.

After all parts are cut out with the jigsaw, drill the 4mm mounting holes required for the ignition panel. Despite the inclusion of the self-tapping screws in the product’s package, we’re choosing to drill out mounting holes for M3 nuts and bolts so we can remove and reinsert the panel whenever necessary. If you plan to use the self-tapping screws included with the panel, skip this step!

Button and Light Holes

There are a total of 25 holes to be drilled for this dashboard. To ensure that all of the holes we are drilling are centred, it’s important to drill pilot holes. On the design template we’ve included, there are crosses that denote the centre of each drill circle. MDF is very easy to tear apart even with a relatively small drill bit, so be careful when drilling and check the opposite side of the panel.

For the shift meter holes, we need to figure out how large we want the LED holes to be. A simple application of Pythagoras theorem (so much for not being used after high school maths classes!) with an LED dimension of 5mm x 5mm yields a drilling diameter of just over 7mm. We used a drill diameter of 8mm to provide enough wiggle room for the LEDs.

Removing the Template

Depending on how you’ve attached the template to your sheet of MDF, you may need to get creative with how you remove it before attaching the carbon fibre vinyl. After discovering the paper was very well stuck to the panel, we had to use sandpaper and a 3D printing scraper to remove the remains of the paper. This will very likely make a mess of paper and glue. As long as the resulting panel is flat, it doesn’t matter if there are small imperfections in its surface, since we’re covering it anyway.

Test Fitting Components

Test fitting the components before we apply the final is very important, since modifying component holes that don’t quite fit is a lot easier now! We tested the fitting of our tachometer, panel pushbuttons, and ignition panel to ensure that the holes we made hold the components tightly. At this point, it’s also a good idea to experiment with layouts for your dashboard to see what will work best with the vinyl you plan to use.

Applying the Vinyl

The carbon fibre vinyl we’ve chosen to use for this project will add a professional touch to the finish of the project, despite being made of rather cheap materials. If carbon fibre isn’t your cup of tea, feel free to swap it out with other coverings. A plain matte black vinyl or Alcantara covering could be used instead depending on what look you are going for.

The carbon fibre wrap is somewhat thick so air bubbles are not a huge concern. The best way to smoothly apply the vinyl is to start on a short edge of the dashboard and use a credit card to slowly apply it across the MDF panel.

Approximately 2-3cms should be left around each edge of the dashboard so that the remaining vinyl can be tucked underneath the main panel to prevent any wood from showing.

For the corners, cut out shaped slits to help the vinyl smoothly wrap-around edges. If your vinyl is as thick as ours is, you may find this difficult since the vinyl may crease up around the curved edges. Be sure to run your thumb across any edges you fold over, as a tight fit must be applied to keep the vinyl on. You may need to use strong tape on the back of the panel to keep small pieces of vinyl from coming loose.

Don’t worry about trying to mould it into any cut-outs, since after we’re done we can simply redrill the button slots and use a craft knife to cut out any jigsaw holes. Most of our dashboard components have a bevel so they’ll cover any imperfections in their mounting holes. The exception to this is the 16 holes for the shift meter – since our RGB LEDs sit behind the dashboard as opposed to in front of it, we need to be careful to produce a smooth finish inside the holes. If you find the carbon fibre is not fully able to cover the wood within the holes, use a black permanent marker or paint to cover up any wood.

Shift Meter

The LEDs for the strip light meter can now be added. How you choose to add this is up to personal preference, but we’ve opted to mount the strip behind the MDF panel – such that we can only see the 5mm x 5mm RGB LED squares. That way, we won’t have to see any ugly copper connections or strip electronics since it’s all hidden behind the panel.

Unfortunately, we discovered that the spacing for our LED strip wasn’t quite perfect – after around 7 or 8 LEDs, the spacing diverged enough so that the LEDs couldn’t quite line up through the holes.

If you find the spacing on your LED strip is slightly different than the template we’ve provided in the project files, you can go ahead and mark out your own drill holes to appropriately fit your strips. Although our template is set up for strips that are sold as 60 LEDs/m, we found that the slight differences in spacing are enough to offset the installation of the strips. We highly recommend you check the spacing on the template matches the spacing of your LEDs.

Luckily, most addressable LEDs can be cut and resoldered on the copper tabs. We cut our strip on the 8th LED and re-bridged the strips together with copper wire around 2mm apart. In your build of this project, you may not have to do this depending on the exact spacing of your strip.

After we verified the LEDs could fit into the drilled holes, we used a permanent marker to darken the visible wood. In this step, as much visible wood and vinyl should be removed for a clean path for the LEDs to illuminate. After inserting the LEDs into the holes, we used a strip of strong duct tape to secure the LEDs to the back of the dashboard. If positioned correctly, this also has the added benefit of keeping the carbon fibre vinyl on the back of the dashboard from peeling off the wood!

The LEDs should now be visible in the front of the panel, but we can add a finishing touch to their appearance by adding material that diffuses and spreads the light. The LEDs themselves emit very intense light, so we’re adding some self-adhesive clear surface protectors on top of them. You read that right, we’re using sticky circles typically used for protecting knocks against furniture in an electronics project! These are awesome for this use as they provide a soft diffusion and circular globe-like appearance to the project - not to mention covering up our ugly drill holes! We used 12mm clear surface protectors, sourced from Bunnings Warehouse. Note that you should be very careful applying them as they tend to pick up fingerprints on the adhesive as well as tear off the sheet in weird shapes.

Support Stands

If you want to add a slick finish to your PC dashboard, we have included files for 3D printed stands that can be screwed to both sides of the MDF panel. To print it, we suggest using a strong infill and a filament colour that matches the theme of your dashboard.

Inserting the Parts

Finally, it’s time to insert all of our parts and complete the dashboard. We started by lining up our support stands to the back of the dashboard and inserting a 15mm M3 screw through the dashboard, after pressing M3 nuts into the back of the stands. They should screw cleanly in and keep the dashboard upright.

Note: At the time of writing, we didn’t have any 15mm screws available so 25mm ones were used instead – 15mm screws will be used in Part 2 of the project and will look a lot cleaner than what is shown in the photos here.

We then screwed in our tachometer, feeding the wires through then sliding on the sleeve to hold it straight. If you would prefer a more performance-orientated dashboard, feel free to rotate your tachometer 90 degrees to make the upper RPM ranges more visible at the top of the dashboard – many older Porsches and race cars did this to make timing gear shifts more convenient.

When inserting the buttons, be aware that many will include a spring or shake-proof star washer to help adhere to the wood surface. They can be placed on the back of the dashboard so they will hold the buttons and switches in place.

The securing nuts on the rear of each button should be tightened enough so they cannot be rotated by hand from the front of the dashboard – any tighter and you risk damaging the MDF or the plastic button body thread.

WHERE TO FROM HERE?

There are quite a few changes that could be made to the physical construction of the dashboard if you wish to improve its design or functionality. Adding metal supports or other heavy weights to the dashboard will make it less likely to slide around on your table – we found that pressing the heavier sprung buttons with one finger made the entire dashboard slide backward. Rubber grips could also be added to the supports to reduce this.

If you plan on using the dashboard without any ambient light, it might be a good idea to add backlight to specific, commonly used buttons, or the entire dashboard to both improve its looks and usability. If you already own simulation hardware, you could even add your own custom mounting hardware to secure the dashboard directly to your steering wheel or sim rig for additional immersion.

NEXT MONTH: PART 2

With the physical construction of the dashboard finished, we now have to work on constructing the electronics and uploading the code to make it all work together! Next month, we’ll be walking through how you can hook up all of the dashboard buttons to the joystick controller and building the circuit to drive our LED displays.

Don’t worry, it isn’t as complicated as you might think! After we’ve finished our hardware circuits, we then can finally move onto uploading the driving code for the project with SimHub. SimHub is an incredibly powerful software for interfacing with racing games, and we'll only be scratching the surface with what you can accomplish to finetune your racing simulator experience.

Nonetheless, we will show you how to initialise all of your equipment with Windows and any racing games you own to finally get this awesome dashboard running.

PART 2