Build this Raspberry-Pi powered head unit to add navigation, music, communication and even vehicle diagnostic features to virtually any car!

BUILD TIME: A weekend
DIFFICULTY RATING: Intermediate

Across modern vehicle manufacturers, we’re seeing more and more implementations of smart communication tech that makes navigation and communication easier. While this shouldn’t come as news, there is an increasing prevalence of adding these highly convenient features to base models of cars. Bluetooth, voice recognition, and satellite navigation are now virtually ubiquitous to even small economy cars.

NOTE: Depending on your vehicle and the quality of 12V supply, you may want to add additional filtering and protection against "dirty" 12V power for longevity of your installation.

However, many of us don’t have modern vehicles, by today’s standards. In fact, nearly 45% of all passenger vehicles on the road in Australia are manufactured before 2010, according to recent Census statistics. While navigation and communication features were available in these cars, the older technology tends to be much slower and incompatible with newer standards like hands-free Bluetooth and Android Auto. Cars built before the early 2000’s usually only have radio and CD capability.

Recently, we came across an awesome Raspberry Pi-based software called OpenAuto Pro. For a reasonable price to purchase the software’s license, you get access to a plethora of features that essentially turns a touchscreen and a Raspberry Pi into a fully-fledged head unit for your car!

OpenAuto Pro is installed onto Raspbian OS, ready to be configured extensively to suit your vehicle. Of course, you don’t have to use OpenAuto Pro. As the Raspberry Pi is essentially a computer in a palm-sized package, you can write your own Python or C programs to display the information you want to see on your car’s dashboard.

IMAGE CREDIT: BlueWave Studios

We wanted to go one step further than making a janky setup with wires hanging out everywhere, or being one speedbump away from everything falling out of the dashboard – as seems to be commonplace with similar projects we found on the internet. The objective of this project is simple: Build a DIY car touchscreen that looks good, runs fast, is well built, and fully customizable.

Getting a basic smart entertainment unit going with OpenAuto Pro and Raspberry Pi is actually fairly easy. Connect a touchscreen, connect a phone over USB, add a Bluetooth adapter, sound card, and finally a micro-USB cable for power, and voila! A working touchscreen unit for your car. According to BlueWave studios, the authors of the OpenAuto Pro program, that’s all you need to comfortably get going.

But as the saying goes, ‘Anything worth doing is worth doing well.’ So, we’re going to streamline this project with some additional goodies to integrate the touchscreen seamlessly into your vehicle, including a power control circuit, RGB mood lighting, a custom 3D printed faceplate, and full hands-free functionality.

The Prototype:

Setting up OpenAuto Pro

To get started with OpenAuto Pro, you’ll need a licence from: https://bluewavestudio.io/shop/openauto-pro-car-head-unit-solution/

After ordering, the developers will send a download link and a serial number to you. Using the Raspberry Pi Imager, you’ll need to image this file across to a microSD card – we recommend using a 16GB card for sufficient storage. Be very sure that you’re imaging the right card as it will format the target media entirely.

Then, just pop the SD card into your Raspberry Pi and connect power. The OpenAuto developers have overwritten the default splash screen to show a spinning OpenAuto loading screen (We later overwrote this with our own DIYODE splash screen, but you can buy or make your own!). Then, just punch in the Serial number you received over email and voila – you now should now be on your home screen. The great thing about OpenAuto is that while very simple to get going, it’s infinitely customisable to suit your vehicle.

Android Auto

It’s worth noting there is a distinction between OpenAuto’s software and Android Auto itself. OpenAuto is a standalone software that runs on your Raspberry Pi, and will happily work without phone or Bluetooth connection – although there is a large degree of functionality that isn’t available. OpenAuto is effectively a car-friendly base program with GUI, to run software such as Bluetooth audio, OBDII dashboards, and more.

Android Auto can only be used when an Android phone is connected to the Raspberry Pi over USB (or WiFi, if set up). It’s effectively a clever “thin client” setup, where your phone does most of the processing including music streaming and GPS management, which is then relayed to your touchscreen head unit. Therefore, external devices like GPS modules aren’t needed as it’s handled all by your phone.

If your phone is connected over USB, you also can charge your phone battery as it’s running on the Raspberry Pi’s 5V rail. In our experimentation, this current is around the 500mA mark, so don’t expect a lightning-fast boost to your battery – but for long car trips, it’ll keep your phone topped up. Handy!

Regarding the Android Auto software itself, not all apps are available, even if they are installed on your phone. YouTube, Chrome and all social media don’t show up on the display for the simple reason that it’d be very unsafe to use them while driving. Saying that, essential apps like your Phone app, music streaming services (e.g. Spotify or TIDAL) and navigation apps are available. These are, however rather stripped back intentionally to avoid users trying to fiddle around with tiny buttons while driving. It’s a streamlined experience that can easily trade punches with the smoothness of the latest car infotainment systems, especially if used with the latest Raspberry Pi 4. We particularly liked the Waze navigation app due to its nifty way of spotting issues in traffic. By tapping the ‘Incident’ button in the corner of the screen, you can mark heavy traffic, hidden speed cameras, or even broken-down cars to let other Wazers know before they come across the issue.

# Untested. * Quantity required, may only be sold in packs.

Let’s talk Audio

A big factor for using a smart head unit is better integration of your favourite music and podcasts. Depending on your specific vehicle, it may be convenient – or desired - to buy a new amplifier for the audio setup.

The car we’re installing the head unit in already has a capable amplifier, plus, in order to make it work with steering wheel controls and the existing LCD displays, we need to keep the stock amplifier. We could experiment with installing our own adapters and interfaces, but this adds more time onto what should be an arguably (electronically, at least) simple project.

We hence decided to ‘piggyback’ the Raspberry Pi and its related gear inside the existing radio unit. We had enough room to make it fit by pulling out the CD player module – not going to be using that in 2021, sorry!

We also designed and printed some temporary supports for the Raspberry Pi touchscreen so we could drive around for a few days with the touchscreen to spot any issues before designing the main build.

A touch of reverse engineering was required to find the appropriate solder pads to hook into the AUX cable inside the radio unit – a left, right, and ground wire was all that was needed to make it work.

We had a number of issues getting Bluetooth audio working smoothly for the smart head unit. It’s very important not to get a poor-quality USB Bluetooth adapter from online ecommerce sites like eBay. We tried three different variants of these adapters and the results were all varying degrees of awful.

The eBay Bluetooth Adapter graveyard. Get a good quality one.

The first one we tried didn’t connect to a smartphone at all, while others had terrible audio dropouts and were generally a pain to get working. They often include generic or poorly-cloned variants of the CSR 4.0 Bluetooth chipset. Jaycar’s XC4956 adapter, however, seems to work well. We also modified the following line in /etc/pulse/default.pa and this helped to solve the vast majority of audio drop-outs:

load-module module-udev-detect tsched=0

Adding tsched=0 to the end of the line tells the Pulse Audio driver to use interrupt-based audio timing instead, which is reported by the OpenAuto developers to solve many dropout-related issues.

Apple Carplay

We’ve only addressed using Android Auto in this project, solely due to its simplicity and adaptability to user preference. However, it’s possible to use Apple CarPlay with OpenAuto Pro by purchasing the AutoBox plugin from the OpenAuto store. You’ll also need a CarLinkIt adapter to plug into the Pi’s USB port, which can be ordered from https://carlinkitcarplay.com/. After the Serial number of the CarPlay plugin is entered into OpenAuto Pro, the AutoBox plugin should work much the same way as Android Auto.

Adding tsched=0 to the end of the line tells the Pulse Audio driver to use interrupt-based audio timing instead, which is reported by the OpenAuto developers to solve many dropout-related issues.

Power Control Circuit

The prototype build electronics for this project are very important! Since we’re putting electronics into a car with an (unfortunately) non-infinite battery, an incorrectly designed circuit could flatten the battery and prevent the starter motor from turning over. So, it’s in our best interest to ensure the circuit draws as little current as possible when the car is turned off, but can safely and reliably deliver the required current when turned on.

On the first inspection, the simple solution for powering the Raspberry Pi would be to power it off the car’s Accessory line. This way, when the key is turned in the ignition, our head unit turns on, and when we remove it, the head unit turns off. However, there proves to be some issues with this approach.

Since the Pi is essentially a mini computer, suddenly removing the power is the equivalent of pulling the 240V plug from your desktop computer instead of clicking on the “Shutdown” button – ouch! If the Pi is in the middle of doing something important and writing to the disk, this data could be corrupted when we try and access it again. In practice, removing the power from the Pi doesn’t cause immediate issues, but if our system is designed to do it every time it’s in use, it’s almost guaranteed to cause all sorts of problems.

Our solution to this problem is a custom timing circuit that charges and discharges a capacitor to let the Pi safely shut down before cutting the power using a MOSFET. It might look over-complicated, but fundamentally it’s very simple and can be used for a number of different applications. By charging or discharging a capacitor at a certain rate through a resistor, we can test if the voltage of the capacitor is above a certain threshold. If we’ve exceeded the threshold, we can enable a MOSFET to electrically enable or disable the Raspberry Pi.

To test the circuit on a breadboard, we slotted in a SPDT switch to act as the ignition switch – I.e. connecting a signal to 12V when the switch is closed.

Before we insert any of the components needed for the power switching circuit, we need to make sure the Pi is aware when the ignition state of the car changes from off to on. To electrically isolate the Pi, we’re using an optocoupler. For those unfamiliar, an optocoupler is small package consisting of, simplistically, a light emitter and a light detector. Neither component is openly visible, but their purpose is to isolate the signals of two circuits since light cannot conduct current. For more reading, we have a full article in Issue 33 about optocouplers. In the configuration we’re using, the grounds are shared, so it’s not technically isolated. However, it will still insulate the Pi from any spikes on the high-side ACC line and thus avoid killing a GPIO pin.

Not shown in the photos, you’ll also need to add a pulldown 10kΩ resistor to keep the optocoupler transistor in a known state, and two wires from the Pi for 3.3V power and an open GPIO pin. These are shown in the Fritzing.

Finally, we can get onto the core of our power circuit. This consists of another switch for enabling or disabling a delay when the car is turned on, and a capacitor for storing a small amount of charge. The large 1MΩ resistor is to slowly discharge the capacitor. We’ll explain how the configuration works in the next section.

The LM393 comparator will compare two voltages; the small capacitor and a voltage divider with two large 1MΩ resistors. Although the LM393 is a dual-comparator chip, we’re only using one. All that is required is power (permanent 12V power, not ACC) a ground signal and the two inputs.

Finally, we can slot in the P-Channel MOSFET to turn on and off the Raspberry Pi. A P-Channel MOSEFT operates high-side, so it won’t upset the ground of the Raspberry Pi and avoid causing strange ground loop behaviour, potentially messing with audio signals. The MOSFET needs a pullup resistor to keep it turned off without a signal from the comparator.

For a moment, let’s step through the process to see how the circuit works fundamentally. When the car’s ignition is first turned on, the ACC (Accessory) line is connected to 12V, to signal the radio accessories to turn on. The switch in parallel with our charging resistor (300kΩ) is to provide an option of whether or not to delay the screen turning on when the car is started, as the voltage of car batteries drop low enough during start-up to temporarily cut power to accessories. We left this turned off most of the time as it seemed our Raspberry Pi was happy running when the starter motor was turning over. If the switch is closed, current from the ACC line is allowed through the diode to charge the 10uF capacitor. Since there is no resistor limiting the current inflow, the capacitor is allowed to charge virtually instantly.

The next part of the circuit is the LM393 comparator, which simply compares the voltages on its two inputs and outputs a signal if the non-inverting input is higher than the inverting input. We chose the LM393 in particular due to its very low power usage of around 0.5mA - acceptable for the parasitic draw of the car battery.

Connected to the inverting input is the capacitor, and connected to the non-inverting input is a voltage divider consisting of two 1MΩ resistors. By using two equal values of resistors, our threshold voltage should be around half of the car’s battery voltage, in practice around 6.5V. The high values are important to reduce current draw of the battery.

Once the car is turned off, there is no longer any current flowing into the capacitor. The diode prevents the capacitor discharging anywhere else but the 1MΩ resistor. While the capacitor is quite small, the resistor is so large that it takes multiple seconds to discharge.

Note: With 22µF capacitor.

So, to summarise, our comparator simply tests if the capacitor voltage is less than half the battery voltage, and if so, turns off the output. The output of the comparator is a P-Channel MOSFET to turn on the Raspberry Pi. Handily, the delay time after turning off the car can be described by this equation:

T = -RCln(½)

T = -1MΩ x 10uF x ln(½)

= 6.931 seconds

In practice, the time isn’t quite exact and tends to deviate by a few hundred milliseconds. But for such a simple circuit, it’s very reliable and highly effective. In all honesty, we probably over-engineered it but it should spark some ideas with how to create custom timing circuits.

A note about the power circuit

The power circuit we designed isn’t perfect, but is definitely acceptable for this application. If you want to improve further on the circuit, a good option would be to add some hysteresis to the comparator consisting of a couple of resistors. A Google search will show the appropriate configuration. We won’t go in-depth with the explanation, but all this essentially does is make the switching of the comparator cleaner and more reliable, preventing the MOSFET from operating in its non-linear region (i.e. forcing it to be fully on, or fully off.)

The other issue is using the 300kΩ slow-charge resistor instead of the short-circuit switch throws off the delay timing. Since it acts as a voltage divider with the 1MΩ discharge resistor, it tends to drop the input voltage at the capacitor from (measured) ~11.3V to ~9.5V, preventing it from charging fully. This means the delay time when the car is turned off is nearly halved. If you’ve got any ideas with improvements to the circuit, let us know at @diyodemag.

Python Script

When the circuit activates the shutdown delay, we need to ensure that the Pi recognises the change. A simple Python script that constantly polls the optocoupler pin will do the trick.

import RPi.GPIO as GPIO
import time
import os
import syslog
GPIO.setmode(GPIO.BOARD)
GPIO.setup(18, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
syslog.syslog("Starting shutdown detection script...")
if not GPIO.input(18):
  print("Failsafe activated!")
  syslog.syslog(syslog.LOG_ERR, "Failsafe activated!")
  print("Cancelling shutdown script...")
  syslog.syslog(syslog.LOG_ERR, "Cancelling shutdown script...")
exit()

This section of code may seem unnecessary, but keep in mind that if our code is written incorrectly, it could easily make our Raspberry Pi unable to boot. That is, if the Pi incorrectly thinks it should shut down as soon as it boots up, we won’t be able to fix the script!

The failsafe ensures that if we read a LOW value when the script starts, we instantly kill the script to ensure we can still access the Pi. If our circuit or script malfunctions, we can simply connect the GPIO pin to ground, and the Pi will still boot. This check is only done once to ensure that it does not interfere with the script in its infinite loop.

while True:
  time.sleep(0.1)
  if GPIO.input(18):
    print("HIGH")
  else:
    print("LOW")
    syslog.syslog("Detected car ignition is off, shutting down system.")
    GPIO.cleanup()
    os.system("shutdown now -h")

Finally, we enter our infinite loop and continually check the GPIO pin. As soon as it goes LOW, we can shut down our Pi knowing our data will be safely intact. To get the script to run every time the Pi boots, add this to a line before ‘exit 0’ in the /etc/rc.local file:

sudo python /home/pi/Documents/shutdown_script.py &

Replace the address with wherever your script is located, and don’t forget the &! It sets the script to run in the background so it doesn’t interfere with anything else. Later on, we’ll also make a script to control the RGB mood lights and it’ll be added to run at bootup the same way. Testing the shutdown script, here it is in the console:

Building everything up to this point lets us test the finished hardware in our vehicle. While ugly, it’s a fundamental build test that seemed to work very well after we fixed the audio issues and added the shutdown power script.

The Main Build:

3D Printing

* Quantity required, may only be sold in packs.

There are a number of approaches available to integrating the OpenAuto touchscreen into your car, depending on how new your car is, what style of dashboard you have, and so forth. Older cars sometimes have double radio slots that could be adapted for this purpose, or the entire radio faceplate may have to be pulled out to fit your touchscreen. In short, you may need to get creative if you want to install the system with a finish as close to stock as possible.

In the 2010 Mazda 3 I’m installing this project into, for example, the radio unit is integrated with the faceplate, so aftermarket systems cannot be installed without sourcing a custom faceplate. While there are Double-DIN (standard radio adapters) available for the car, I wanted to have a crack at designing and 3D printing my own one. This way, I could design it to exactly fit the 7” touchscreen and any other electronics needed to get it running. Naturally, the models for this project are only suitable for the specific vehicle unless yours has a similar radio unit. We’re still including the models if you want to refer to the design or use its dimensions.

The first roadblock to this was exactly replicating the inbuilt faceplate to make it look as stock as possible. Since I couldn’t find any matching 3D models online, I set up a camera with a long 250mm lens and took pictures of the faceplate and internal amplifier box. If the parts are photographed from orthogonal angles and at a distance, parallax distortion is kept at a minimum for modelling.

To have more control over sculpting the model, I imported the orthogonal photos into the free modelling program Blender and set them up to be the same scale across the 3 axes. Unlike Fusion 360 – our usual go-to modelling program – Blender operates on polygons for describing a model’s shape and size. I won’t discuss the intricacies, but this essentially means that instead of curves Fusion supports, Blender uses a network of flat faces. While Fusion can accomplish detailed modelling, It’s difficult dealing with complex curves across faces of models.

After finishing the reference faceplate model, we imported it into Fusion 360 and began adding more features to complete the model. This included the 7” touchscreen mount and crossbars for adding RGB Neopixel lights later. Separately are the brackets that hold the faceplate to the radio unit and screw into the dashboard. These are attached to the main faceplate by tapping into the plastic with M3 screws.

3D printing can be accomplished by orientating all of the models on flat surfaces; however, we needed a reasonably sized build volume to do the faceplate in one go. We also highly recommend printing in ABS plastic if possible. PLA is virtually guaranteed to melt in the summer, and that combined with the greenhouse effect of a hot car will likely destroy prints within hours. ABS, while fussy to print and avoid warping, is much more resistant to heat and should be more tolerant to knocks and scrapes.

Painting

While the bright silver filament has a nice finish, it sticks out like a sore thumb in my car so I opted to spray paint it a colour as close to the interior as possible. First up though, I sanded it with increasing grits of sandpaper (320, 800 and 1600) to remove the layer lines on the model. It’s worth spending some time on this to get a nice finish after spray painting.

I added two coats of plastic and fibreglass primer to fill in some small gaps of the plastic layers, followed by three coats of touch-up paint that matched my interior colour as closely as possible. While I was at it, I soldered together the NeoPixel backlight strips and mounted them on the four corners of the screen. These need to have wire connections soldered onto them for 5V, Data, and Ground and can be daisy-chained.

The internal bracket won’t be as aesthetically pleasing as the faceplate, but its main purpose is to house the main electronics including the Raspberry Pi, the sound card, and the power control circuit. It won’t be seen since it’ll be mounted inside the existing radio amplifier.

After checking everything fits properly, we started assembling the power electronics. The electronics are exactly the same as the fundamental build, with the exception of an additional 1N4007 diode for the NeoPixel LEDs.

The power inputs are positioned at the top left of the board and consist of 12V (Yellow, always on) wire, ACC (Red, accessory power), and Ground (Brown/black). We later connected these to a row of headers to piggyback into the existing amplifier power.

The optocoupler is connected in the same configuration as the fundamental build, with the light emitter and detector sides both using resistors in current limiting and pulldown configurations respectively. We’re using IC sockets here so if we accidentally blow up a chip, we can pop a new one in – we forgot to grab six-pin IC sockets but an eight-pin works just as well.

We then added the ignition charging switch, the capacitor, the discharge resistors and the 10uF capacitor on the right side of the board. The configuration can be slightly confusing on compact boards like this so refer to the including Fritzing and schematic if you get stuck. The P-Channel MOSFET can also be slotted in and soldered to the far-right side, taking care to get its orientation correct. It will carry all of the current of the Raspberry Pi, touchscreen and any connected USB accessories so make sure it has good electrical contact.

Finally, we added the 12V-to-5V converter into the circuit, the 12V input between the MOSFET and Ground. Any good-quality buck converter capable of delivering more than 3A and can step down from around 12V should work, however, we tested multiple and couldn’t find any luck.

The Pi often managed to collapse the output voltage of the converter and would refuse to boot. We weren’t sure of why it tended to do this and didn’t have enough time to find out. We eventually ended up disassembling a spare 12V phone charger and using its internals.

The 5V output can be connected to a header, and an additional header pin can be added to output 5V, with an added 1N4007 diode in series. This diode is not actually for reverse polarity protection but is instead used for its voltage drop – in order to create a lower voltage for the backlight NeoPixels.

If we feed the NeoPixels the full 5V, it is likely that the 3.3V signals from the Raspberry Pi will not be able to interface with the LEDs. We need to drop it closer to the logic level, and the ~4.3V output from the diode should do the trick! This is a quick shortcut to getting 5V NeoPixels running on 3.3V, however, you shouldn't run more than about 20 LEDs as it may overload the diode.

Backlight

We used an example of Adafruit’s NeoPixel Python code to run a slowly rotating rainbow wheel around the perimeter of the touchscreen. We won’t show the code here, but it’s important that the NeoPixel data pin is connected to GPIO10, GPIO12, GPIO18 or GPIO21. After adding it to the rc.local bootup script, we can generate some awesome mood lighting, the reflection of which is visible from behind the screen.

With the electronics complete, we can screw and slide everything into place. The internal bracket is designed to fit with 3M screws and nuts, and to zip-tie the USB sound card.

OBDII Dashboard

OBDII is a vehicle diagnostics protocol that, historically, allowed mechanics to get to the root of many sensor-related issues on vehicles. While it existed earlier prior to the mid 1990s, it was very basic and no widespread standard existed to make connections universal on every vehicle.

In 1994, California (and later in 1996, all of the US) required that every vehicle adopt the ODBII protocol to support diagnostic engine codes. Conveniently, these OBDII diagnostic ports also allowed access to information that the average driver uses constantly while driving such as RPM and speed.

Recently, small Bluetooth or WiFi based adapters have made accessing this information incredibly cheap and simple for everyone, not just technicians. It’s possible to pick up a OBDII adapters for a DIY project without breaking the bank.

PP2145 from jaycar.com.au

OpenAuto Pro handily supports Bluetooth OBDII adapters which makes it incredibly easy to set up a live diagnostics vehicle display. By default, it displays the most commonly used statistics including RPM, Speed, fuel usage, intake pressure/temperature, but custom PIDs can also added for vehicle-specific sensors for even more fine-tuned displays. If OpenAuto Pro doesn’t go far enough for you, you can also use the Python OBD library to write your own Python scripts for custom displays or data logging.

To set it up, you’ll want to slot your adapter into the OBDII port in your car, typically located near the driver-side door and steering column, under the dash. Once the Raspberry Pi and adapter have power, simply pair it using the Bluetooth menu and take note of the MAC address.

Head into /home/pi/.openauto/config/openauto_system.ini and change the following parameters (obviously replacing the MAC address with that of your adapter).

ObdDeviceType=2
ObdAdapterRfCommAddress=00:00:00:11:11:11

OpenAuto will take care of the data from there, so just head into the Dashboards app from the main screen and select a dashboard. OpenAuto Pro should connect and automatically query live information from your car.

Depending on the car, the update and latency rates seem to vary, but with my Mazda, it’s very responsive – it sometimes seems to respond faster than the stock tachometer and speedometer. Whether you use the OBDII feature as a tool to keep an eye on your temperatures or just for showing off your now high-tech car, this is an awesome bang-for-your-buck addition that is usually limited to high-end car displays.

Installation

After finishing the electronics, painting, and software, we can finally get to installing the touchscreen unit into the vehicle. This process will be different in every vehicle, but in my case, it involved first pulling out the AC vents and running the USB and microphone cables behind the dashboard. I used two USB cables, one as an USB-A extender for other accessories like a keyboard, and one as a USB-C cable for my phone. I routed these down to the left-side passenger footwell and down into the centre console so I can put my phone out of sight when driving.

I used a small lavalier microphone from Jaycar for hands-free calling and voice assistant functionality, which I routed through the driver side footwell, up the inside of the door trim, and finally slid it into the A-pillar close as possible to a speaking position when driving. The microphone has a fairly short range so it’s worth positioning it to get clear call quality. Also, be sure to keep any routed cables out of the way of any moving parts – the steering column, pedals, and air conditioning components come to mind. Zip ties do wonders here.

My objective of this project was to not irreversibly modify any factory parts, so I opted to instead Dremel parts of the 3D printed faceplate that didn’t quite fit to squeeze it into the dashboard. The panel gap of the faceplate was acceptable, about 1mm on top and bottom, and 2-3mm on the sides. It doesn’t look quite good enough to look as though it was from the factory, but good enough to nearly be considered non-DIY!

The power circuit works a treat and safely shuts down the Raspberry Pi when required, and the NeoPixel RGB lights are a nice touch, especially for night driving where it becomes especially visible. Since it’s driven by Python code, we could even add reactive lighting for engine RPMs through OBDII or a Bluetooth music visualizer.

Troubleshooting

This project involves a wide variety of hardware and software, so there is, unfortunately, a number of roadblocks that are easy to hit. On the software side, the Raspberry Pi is very well supported and a quick Google search should result in some helpful Stack Overflow articles – you’ll just need to get used to the Linux terminal.

Since the developers of OpenAuto Pro have had to work with a number of software APIs and integrate functionality for all sorts of vehicle tech, problems usually surface from installation to installation. Luckily, the forums of OpenAuto are incredibly active and the developers reply very quickly.

One of the biggest issues with OpenAuto Pro seems to be that users tend to misunderstand (or possibly not read) the requirements of the software. External Bluetooth and sound cards are required, not just recommended. Android Auto will likely not launch or function well without them. Since OpenAuto is tethered from your phone, you may also need to check your Android Auto settings on your phone to ensure it’s correctly set up.

On the hardware side, check that your Raspberry Pi is receiving sufficient power by measuring the voltage at the input terminals or micro-USB cable. Undervoltage is a very common problem since the Pi tends to draw a fair amount of current, so your 12V-5V converter should be capable of at least 3A, preferably more. Use a different converter, or run it off a 12V socket USB adapter if in doubt.

Check that your vehicle is supplying the voltage on the connections it’s supposed to, otherwise, you may have inadvertently blown a fuse and need to replace it. There are typically two fuses, one for the battery Ignition line and one for the interior accessories, in my car called ROOM. Just make sure to fix the problem before you do so, otherwise, the fuse will pop again.

Where To From Here?

Depending on your budget, functional and aesthetic tastes, OpenAuto Pro leaves no barrier for dialling in your touchscreen system to suit your vehicle. Bigger (or differently shaped) screens should all be supported by the Raspberry Pi. Keep in mind that there is other software available for building custom dashboards, some performance orientated if that’s your thing.

OpenAuto also includes support for already existing car features, such as steering wheel buttons and advanced audio amplifier setups such as using HiFiBerry. It also can use reversing cameras, wireless gesture sensor modules, and even automatic night/day mode switching. I’m planning to add a smart home relay to my garage door opener and lights, so I can use the Google Assistant from Android Auto to automatically activate them upon arriving home.

Overall, we’re really impressed with how OpenAuto performs for such an affordable price, including the touchscreen and Raspberry Pi hardware. Comparing it to aftermarket infotainment kits, it’s around half the price and with just as many, if not more, features. During the research of this project, we saw multiple videos online of people modifying 70’s and 80’s era cars with an OpenAuto to give them a modern refresh without ruining the car’s appearance or original hardware. All you need to get started is a 12V connection, a Raspberry Pi, a touchscreen, and a smartphone. Tag us in your own smart entertainment creations with @diyodemag.