For car enthusiasts and DIY mechanics, monitoring engine performance is crucial. When it comes to turbocharged vehicles, keeping an eye on boost pressure is essential for both performance tuning and engine health. While “Obd2 Boost Gauge” might imply a direct OBD2 connection for boost reading, the reality is often about leveraging external sensors and integrating them into your car’s system for accurate boost monitoring. Let’s dive into understanding how you can create your own boost gauge setup, drawing insights from a discussion about pressure sensors and Arduino projects.
Understanding Boost Pressure and MAP Sensors
In the original discussion, the focus is on using a MAP (Manifold Absolute Pressure) sensor to measure boost. It’s important to distinguish between gauge pressure and absolute pressure. Gauge pressure, which is what most boost gauges display, is the pressure relative to atmospheric pressure. Absolute pressure, measured by sensors like the MPX4250AP discussed, includes atmospheric pressure as the zero point.
As JT9001 explains, a sensor reading from 1 to 60 psi absolute pressure will register atmospheric pressure (around 14.7 psi at sea level) even at rest. Therefore, when your engine is pulling vacuum, like -18 inHg at idle, the sensor reads a pressure below atmospheric pressure, but still above its absolute zero. When you’re boosting, say at 20 psi of boost, the sensor will see approximately 34.7 psi absolute (20 psi boost + 14.7 psi atmospheric pressure).
Image showing an MPX4250AP pressure sensor, commonly used in automotive applications for measuring manifold absolute pressure. Alt text: MPX4250AP MAP Sensor for Automotive Pressure Measurement
Decoding the Sensor Math: Transfer Function Explained
To convert the raw voltage output from the MAP sensor into a pressure reading, we need to understand its transfer function. The datasheet for the MPX4250AP sensor provides this, and JT9001 helpfully extracts it:
Papplied (PSI) = (Output (V) - 0.5) / 0.067
This formula tells us how the output voltage of the sensor relates to the applied pressure. The provided Google Sheet further illustrates this, showing key voltage outputs for different applied pressures. For instance, at approximately 0.890V output, the sensor is reading around 5.85 PSI applied pressure.
This linear relationship is crucial for programming a microcontroller like Arduino to interpret the sensor readings correctly and display them as boost pressure.
Arduino Code for a DIY Digital Boost Gauge
The provided Arduino code snippet gives a practical example of how to build a digital boost gauge. Let’s break down the key parts:
// include the library code:
#include <LiquidCrystal.h>
#include <SFE_BMP180.h>
#include <Wire.h>
int mapsen = 0; // Set MAP sensor input on Analog port 0
float boost = 0; // Set boost value to 0
float mapval = 0; // Set raw map value to 0
float peak = -30.0; // Set peak memory to low number so max displays correctly
float warnpsi = 20.5; // Set PSI for warning
float atmpsi = 13.9637; //Local atmospheric pressure
boolean firstRun = true;
LiquidCrystal lcd(7, 8, 9, 10, 11, 12); // LCD setup
void setup() {
Serial.begin(9600);
lcd.begin(16, 2);
lcd.clear();
lcd.setCursor(4,0);
lcd.print("Welcome");
lcd.setCursor(5,1);
lcd.print("Huma");
delay(5000);
lcd.clear();
}
void loop() {
mapval= analogRead(mapsen); //Reads the MAP sensor raw value
boost = mapval - 1023.5 / 0.067; // Calculate boost/vac levels.
if (boost <0)
{
lcd.setCursor(0,0);
lcd.print("VAC");
lcd.setCursor(4,0);
lcd.print(boost,1);
}
else
{
lcd.setCursor(0,0);
lcd.print("PSI");
lcd.setCursor(4,0);
lcd.print(boost,1);
}
if(boost>0 && boost>peak || firstRun) {
peak = boost;
lcd.setCursor(0,1);
lcd.print("Peak PSI:");
lcd.setCursor(10,1);
lcd.print(peak);
firstRun = false;
}
delay(50);
}This code reads analog input from the MAP sensor, attempts to calculate boost, and displays it on an LCD screen. However, there are a few points to note:
- Sensor Reading:
analogRead(mapsen)reads the analog voltage from the MAP sensor. Arduino’s analog-to-digital converter (ADC) provides a value from 0 to 1023. - Boost Calculation: The line
boost = mapval - 1023.5 / 0.067;seems to be a simplified or incorrect attempt to convert the raw ADC value to boost. It’s not directly using the transfer function correctly and also doesn’t account for atmospheric pressure. - Vacuum/Boost Display: The code attempts to display “VAC” for vacuum and “PSI” for boost, which is correct in principle.
- Peak Hold: The code includes a peak boost value memory, which is a useful feature for a boost gauge.
*Addressing the `.145` Question**
The line in question:
boost = ((((float)mapval/(float)1023+0.04)/.004)*.145)-atmpsi;appears to be a more refined attempt at calculating boost. Let’s break it down:
(float)mapval/(float)1023: Normalizes themapval(0-1023) to a 0-1 range, representing the proportion of the ADC’s full scale.+0.04and/.004: These constants likely relate to the sensor’s specific voltage output range and scaling, potentially derived from its datasheet or calibration. Without the specific sensor datasheet used in this code snippet’s formula, it’s hard to say definitively where these numbers originate.*.145: This factor,0.145, is very close to the conversion factor from millibar (mb) to PSI (1 mb = 0.0145037738 psi). It suggests the sensor or calculation might be initially in millibars and then converted to PSI.-atmpsi: This subtracts the atmospheric pressure (atmpsi) to convert from absolute pressure to gauge pressure (boost).
Saab MAP Sensor Compatibility
The user also inquires about a Saab 9000 MAP sensor (part number 9132374). To determine compatibility, the key is to find its datasheet or specifications. Look for:
- Voltage Range: Is it a 0-5V sensor, compatible with Arduino’s ADC?
- Pressure Range: Does it cover the desired boost range for the application?
- Transfer Function: This is crucial for accurate calculations. You need to know the relationship between voltage output and pressure to program the Arduino correctly.
If you can find the datasheet for the Saab sensor, or find information about similar sensors used in Saab 9000s, you can adapt the Arduino code and calculations accordingly. Online Saab forums and communities might also be valuable resources for finding this information.
Building Your Own OBD2-Inspired Boost Gauge
While this project focuses on a direct sensor and Arduino setup, it’s a foundational step towards understanding how boost gauges work. Although not directly OBD2 in this implementation, the principles of sensor reading, data processing, and display are the same.
For a true “OBD2 boost gauge,” you’d typically use an OBD2 reader to access the car’s ECU data, if boost pressure is a parameter that the ECU reports via OBD2. However, for older or certain vehicles, or for more direct and potentially faster readings, a dedicated MAP sensor and display system like the Arduino project described remains a viable and educational DIY approach.
By understanding the sensor characteristics, the pressure principles, and the code involved, you can create a functional and informative boost gauge for your turbocharged car. Experimentation and further research into your specific vehicle and sensor options will be key to a successful project.
