Build Your Own Bluetooth OBD2 Arduino Interface for Enhanced Car Diagnostics

For car enthusiasts and tech-savvy individuals, accessing and understanding your vehicle’s data can unlock a new level of insight into its performance and health. OBD2 (On-Board Diagnostics II) systems provide a wealth of information, and with the power of Arduino and Bluetooth technology, you can create your own bluetooth OBD2 adapter Arduino interface to tap into this data wirelessly. This project allows you to stream real-time sensor readings from your car to devices like smartphones or tablets, opening up possibilities for custom dashboards, data logging, and advanced diagnostics using apps like Torque Pro.

This article dives into how you can build a custom Bluetooth OBD2 adapter using an Arduino board and a Bluetooth module, leveraging a readily available code example to get you started. We’ll explore the code, explain how it works, and guide you on setting up your own DIY car diagnostic tool.

Understanding the Basics: OBD2, Bluetooth, and Arduino

Before we delve into the code, let’s clarify the key components of this project:

OBD2 (On-Board Diagnostics II): This is a standardized system in most modern vehicles that provides access to diagnostic data and vehicle parameters. A standard OBD2 port in your car allows devices to communicate with the car’s computer.
Bluetooth: A wireless communication protocol that enables short-range data exchange between devices. In this project, Bluetooth facilitates wireless data transfer from the Arduino-based OBD2 adapter to your phone or tablet.
Arduino: An open-source electronics platform based on easy-to-use hardware and software. Arduino boards are perfect for DIY projects, allowing you to interface with sensors, communicate wirelessly, and process data.
Torque Pro (and similar apps): Android apps designed to connect to OBD2 adapters and display real-time vehicle data, offering features like gauges, performance monitoring, and fault code reading.

The Arduino Code: Bridging OBD2 and Bluetooth

The provided Arduino code acts as the intermediary between your car’s OBD2 system and a Bluetooth connection. It’s designed to communicate with the Torque Pro app, presenting sensor data from the Arduino in a format Torque can understand. Let’s break down the code’s functionality:

Code Structure and Key Components

The code is written in Arduino’s programming language (based on C++) and is structured to handle communication with both the Bluetooth module and the Torque app. Here’s a look at the essential parts:

Constants and Definitions: The code starts by defining various constants, many of which are AT commands. ATI (AT Interface Identification) is one of these, used to request identification information from the OBD2 interface. Other AT commands like ATE (Echo Off), ATZ (Reset), and ATDPN (Describe Protocol Number) are standard commands used in OBD2 communication via ELM327-compatible chips, which are often emulated in software or hardware for OBD2 adapters.
Sensor Array (sensors): This is a crucial part of the code. It defines the sensors that the Arduino will “advertise” to the Torque app. Each sensor definition includes:
- Arduino Pin Number
- Sensor Type (Analog or Digital)
- Input/Output designation
- Default Value (if output)
- Short Name (e.g., “Boost”)
- Long Name (e.g., “Boost Pressure”)
- Units (e.g., “PSI”)
- Minimum Value
- Maximum Value
This array is configurable, allowing you to customize the sensors your Arduino will report to Torque. The example code includes sensors like “Boost,” “EGT” (Exhaust Gas Temperature), and a “Digital Out 1” for demonstration.
Configuration (CONFIGURATION): This constant string allows you to configure Torque app settings. "NO_CAR_SENSORS,NO_DEVICE_SENSORS" hides default car and phone sensors in the Torque app, making it easier to focus on your custom Arduino sensors.
SoftwareSerial: The code uses SoftwareSerial to establish serial communication with the Bluetooth module on Arduino pins 2 and 3. This is important because it frees up the main hardware serial port for debugging via USB.
setup() function: This function runs once at the start. It initializes the sensor pins using initSensors(), starts serial communication with the computer (Serial.begin(9600) for debugging), and starts serial communication with the Bluetooth module (mySerial.begin(9600)).
loop() function: This function runs continuously. It checks for incoming data from the Bluetooth module (mySerial.available()). When data is received, it reads characters, assembles them into a command string (fromTorque), and then processes the command using processCommand().
processCommand(String command) function: This is the heart of the command processing logic. It takes a command string from Torque, compares it to known commands (like ATZ, ATI, GETDEFINITIONS, GETSENSORS, SETSENSOR), and executes the corresponding actions. For example:
- ATI: Responds with the VERSION string, identifying the interface.
- GETDEFINITIONS: Calls showSensorDefinitions() to send the sensor definitions from the sensors array to Torque.
- GETSENSORS: Calls getSensorValues() to read the current values of the input sensors and send them to Torque in the format id:type:value.
- SETSENSOR: Calls setSensorValue() to allow Torque to control output sensors connected to the Arduino.
showSensorDefinitions() function: Iterates through the sensors array and sends the sensor definitions to the Bluetooth module, which Torque Pro uses to recognize and import the custom sensors.
getSensorValues() function: Reads the analog or digital values from the Arduino pins defined as input sensors in the sensors array and sends these values to Torque. It includes example calculations for a boost sensor (assuming a specific sensor model). You’ll need to adjust these calculations based on the actual sensors you use.
setSensorValue(String command) function: Parses the SETSENSOR command from Torque to extract the sensor ID and value, and then sets the corresponding Arduino output pin to control actuators or indicators.
initSensors() function: Initializes the Arduino pins defined in the sensors array, setting input or output modes and setting default output values.
getConfiguration() function: Sends the CONFIGURATION string to Torque, applying the configuration directives.

Customizing the Code for Your Project

To adapt this code for your own Bluetooth OBD2 Arduino project, you’ll primarily need to focus on:

Modifying the sensors array: This is where you define the sensors you want to monitor or control. Adjust the pin numbers, sensor types, names, units, and value ranges to match your actual hardware setup.
Adjusting getSensorValues(): Modify the calculations within getSensorValues() to correctly convert raw analog or digital readings from your sensors into meaningful units (like PSI for boost, degrees Fahrenheit for temperature, etc.). The provided boost sensor calculation is just an example and likely needs to be changed based on your sensor’s specifications.
Hardware Connections: Ensure you connect your Bluetooth module to the correct Arduino pins (Rx to pin 2, Tx to pin 3 as defined in the SoftwareSerial mySerial(2,3); line). You’ll also need to connect your sensors to the Arduino pins you defined in the sensors array.
OBD2 Interface: You’ll need a way to physically connect your Arduino to your car’s OBD2 port. This typically involves an OBD2 connector and potentially an ELM327 chip or a similar OBD2 interface IC if you want to perform more advanced OBD2 communication beyond just reading sensor data that you are feeding from Arduino inputs. For this basic example, the Arduino itself is not directly interfacing with the OBD2 port for vehicle data; it’s simulating an OBD2 adapter by providing its own sensor data to Torque as if it were coming from the car.

Setting Up Your Bluetooth OBD2 Arduino Adapter

Here are the general steps to set up your DIY Bluetooth OBD2 adapter:

Gather the Hardware:
- Arduino board (UNO or similar)
- Bluetooth module (e.g., HC-05, HC-06)
- OBD2 connector (if you intend to connect to the OBD2 port for power or future expansion)
- Sensors (boost pressure sensor, temperature sensor, etc.) as per your sensors array configuration.
- Wiring and breadboard for prototyping.
Connect the Bluetooth Module to Arduino: Wire the Bluetooth module to Arduino pins 2 and 3 (or the pins you’ve defined in your SoftwareSerial setup). Ensure proper power and ground connections for the Bluetooth module.
Upload the Arduino Code: Copy the provided Arduino code into the Arduino IDE, customize the sensors array and getSensorValues() function as needed for your sensors, and upload the code to your Arduino board.
Pair Bluetooth: Pair your Android device with the Bluetooth module connected to your Arduino.
Configure Torque Pro:
- In Torque Pro, go to Settings > OBD2 Adapter Settings > Connection Type and select “Bluetooth”.
- Select your Bluetooth module from the “Bluetooth Device” list.
- In Torque Pro, you may need to go to Settings > Plugins > Manage plugins and ensure that “Arduino Sensor Plugin” (or similar, depending on how Torque identifies it) is enabled. Torque Pro should automatically detect and import the sensor definitions sent by your Arduino when you connect.
Test and Monitor: Run your car, connect Torque Pro to the Bluetooth OBD2 adapter, and check if the sensor values from your Arduino are displayed correctly in Torque Pro.

Expanding Your Project

This project serves as a foundation for more advanced DIY car diagnostics and data logging. You can expand it by:

Adding More Sensors: Integrate a wider range of sensors to monitor various vehicle parameters.
OBD2 Data Integration: For more advanced users, you could incorporate an ELM327 chip or similar OBD2 interface to actually read data directly from the car’s OBD2 system and combine it with your custom Arduino sensors. This would require more complex code to handle OBD2 protocols.
Data Logging: Modify the Arduino code to log sensor data to an SD card or transmit it to a remote server for later analysis.
Custom Dashboards: Develop custom dashboards or interfaces to visualize the sensor data in unique ways.

Conclusion

Building your own bluetooth OBD2 adapter Arduino interface is a rewarding project that combines electronics, programming, and automotive technology. By understanding and customizing the provided code, you can create a powerful tool for monitoring your vehicle’s performance and gaining deeper insights into its operation. This DIY approach offers flexibility and customization that off-the-shelf OBD2 adapters may not provide, empowering you to tailor your car diagnostics to your specific needs and interests.