Electropneumatic boostcontrol this is only useful for turbocharged engines.

Note! For now this page can be considered a brain storming page, stuff that actually works is found here: BoostControl

Info from here should be moved there or OnlineCourse/BoostControl until this page is deleted.


The maximum boost an engine bears depends on many factors, and it varies across loadsites. To get maximum performance, GenBoard/VerThree implements a fully mappable boost-controller.

Take a look at this powerful system for boost control: I strongly suggest that we try to implement something like this. -J÷rgen

Implementation - mapping

One wants to map desired boost (boost_target) in function of RPM and in function of TPS. For the TPS direction, only monotonous function makes sense (it would be silly to apply lower boost for wider throttle). In the RPM direction the boost_target is often decreased near the maximum RPM.

The following 2-dimensional mapping is used (it will be 3 dimensional when gear-input is actually used, setting BOOSTCONTROL_LINES to 2 or above in my_make):

boost_target = config.boost_targetoffs + b[gear,RPM] * t[TPS]

This provides a simply mappable, yet very flexible controller.

b[] is the b table, t[] is the t table while config.boost_targetoffs is a simple configuration value.

There is a choice in config.boost_conf if

is selected.

Currently ADC7 is used for the boost input (it's a free, buffered amplifier on v3.2 when only 1 WBO2 channel is used: called nernst2). It will be selectable in the future (any of the 8 MCP3208 channels).

The unit (of configuration values) depends on the pressure sensor input voltage levels:

Implementation - PID controller

PID controller is used to adjust the actuation command. The PID parameters in config:

  uint8_t boost_pid_kp;   // boostcontrol pid kp
  uint8_t boost_pid_ki;   // boostcontrol pid ki
  uint8_t boost_pid_kd;   // boostcontrol pid kd
  uint8_t boost_pid_ilimit;   // boostcontrol pid integral limit

Implementation - Actuation

config.boost_channel is used to select output that controls the solenoid (choose between 15mA .. 350mA .. 15A outputs) , see GenBoard/Manual/DigitalOut .

It would be theoretically possible to use an ON / OFF valve that cannot be kept in an intermediate state like a PWM-capable valve: it needs to be switched ON / OFF continuously ( eg. at a slower, 20 Hz) when under control. TODO: We have to add support for this, because many such small solenoids are ON/OFF type.

New experimental boost code

Idea is to keep boost solenoid powered while boost_minpressure < boost < (boost_target - boost_control_threshold). After that point solenoid is driven with variable duty cycle (refDC + calculated correction) to keep pressure in required level.


Boost solenoid reference DC% is interpolated from two DC% values at low/high kPa points (both configurable).


It's very easy to tune, just a few parameters to set up. Code has now been tried in two different engines (stock Audi S6 and a tuned RS2) with quite different boost building characteristics and it seems to behave pretty well, although some polishing might still be required.

Open loop boost control

Open loop boost control can be activated from Boost Alternate settings menu. In addition to Open loop-mode selection, choose correct PWM frequency and output channel for boost solenoid.


Duty cycle applied to boost solenoid is read from a boost table according to current RPM:


DC value is used as is, without scaling down by TPS. However if MPC3028 channel is selected from the settings above, DC values may be adjusted by -50..+100% according to value read from ADC.

Closed loop boost control

In closed loop control DC values are read from the boost table according to current MAP and RPM. In the example table below, boost will settle somewhere between 174 and 206kPa lines, since DC will fall rapidly once MAP exceeds 174kPa


Open & closed loop control share the same boost DC table. Open loop uses the bottom line while closed loop may utilize bigger portion of the table

boost control limits for any given hardware

The backpressure in the exhaust will try to open the wastegate, this is prevented by the spring. Thus, a very weak spring can never be used with high exhaust pressure.

Small wastegates with large membranes (large membrane to valve ratio) will often have a larger control range then a large wastegate, which often have the same or only slightly larger membrane size compared to the small wastegate.

A rule of thumb that usually works is that you should have a wastegate spring that give you at least half of your target maximum boost.

Internal wastegates always fall in the 'small wastegate' category. An internal wastegate can sometimes be used up to 3 times it's natural pressure, this is very good for a low power car. But the performance of an internal wastegate is unpredictable, sometimes they won't seal properly and boost will increase slowly. Sometimes they work great until you reach a certain flow, where they won't be able to regulate pressure even if they are wide open. -J├Ârgen

naive approach - without TPS it would be poor

to have a

This results in poor drivability. If you want to try it, set t[] table to all FF.

boost-target or MAP-target

Generally we only care about MAP. (more exactly we care about engine torque, but that's hard to measure).

That hints it makes more sense to have MAPtarget rather than boost-target.

However any reasonable MAP-target depends heavily on TPS (while boost-target only depends slightly from TPS), which means

on the other hand, boost-target

What conditions could be used to have best of both worlds?

From the above, it seems to me that MAPtarget is rather an economy thingy on factory cars. If possible, a boost-sensor is favorable.

mechanical safety BOV

(that vents to environment) is recommended anyway, so if throttle is released very suddenly, the boost won't go sky-high.

Anything below is old, or for developers ... should be organized - split to pages, etc...

Target must be function of (RPM, TPS) was: brainstorming

The better approach is to make boost-target or MAP-target

depend on (RPM, TPS) vector.

Either a

other config items:

Eg. there is an RPM dependent P pressure (relative to ambient 1 bar) target active at say TPS > 95%.

And there is a transfer function (of TPS) which determines what the target pressure will be at a given TPS. Eg it can say something like

(linear interpolation, more bins, etc...).

Without incrementing the pressure target artificially, with a large throttle there would be very little difference in power between TPS=60% and TPS=95%.

Similarity to idle control

boostcontrol is very similar to idle control

so another variable (boost/RPM) reaches it's target

depending on gear is a hack without g-sensors - related to TractionControl/Algorithms

Some people have problems (under some circumstances) to NOT press throttle fully when they need less power (eg. in lower gear to prevent loss of traction). This can be helped somewhat with lower boost in lower gears.

Note that a simple solution that depends on gears works well (==near traction limits with fully pressed throttle) only for flat ground. A solution that works for any g (such as a bump) requires g-sensors, and ideally full TractionController with wheelspin sensors. The TractionController should decrease boost (along with other actions) when necessary.

Couple of interesting links to Pneumatic boost control!

The solenoid activation approach as used by the current Japanese electronics is quite flexible. They either block or bleed the boost line until the pressure is needed to open the wastegate (depending on wastegate type).


Here's a pic of the valve itself. It's a 3-way with NO, NC, and COM ports. For external wastegastes, the pressure line is connected to the NC port, while integrated wastegates use the NO port. Nothing special about it by the looks of things, just your regular air bypass solenoid.


We need something that can handle at least 4 bar (3 bar + atmospheric) and runs on 12V. 3 way lets us bleed off boost pressure, and works with both internal and external wastegates. I had a quick look on and found a Picosol 3 way valve, rated at 6 bar and consuming only 1W. Specs [here]. There is also a options with larger orifices if we are prepared to a) settle for 2 way valve, and/or b) drive higher current solenoids.

My concern with the little Picosol valve is the small flow area. SMC has some 307 valves which are fairly cheap and small, and larger 317 valves with a 12 mm^2 area. Bigger is better here, as it gives a larger flow rate and faster response. Whether it's enough to matter is something else again.

This schematic on the picture is great. I think a new table could be made for boost control. Maybe b-table. It could be RPM, and TPS dependent. We could set the boost target for everey RPM and TPS position(in %). The same method is used in MOTEC electrinocs, and works well in several rally cars in the world.What do you think?

Everything needed for boost controll is already available in the AfreshTiny Lambda meter, meant to be used as Boost control or Wideband Lambda meter.

Is it worth integrating a few things too?

It's probably good to check out the competition, so here's some current aftermarket offerings:


[Greddy Profec B-Spec II] (MembersPage/RichardBarrington has this one)

[Greddy e-Manage]

[Blitz D1 SPEC SBC i-D]

[A'Pexi AVC-R]

[Turbosmart e-Boost]

And some reviews of some of them:

A problem I about to face is the frequency of the PWM:

PWM frequency will be dependent on the type of coil in the solenoid.

Norgren do solanoids:


Earlier experiments - from Finland

I have tried out couple of selfmade boost controllers:

unsigned long RC_Filtter(unsigned long current_value){
 static unsigned long Old_Value; 

     if(current_value>Old_Value) Old_Value=Old_Value+((current_value-Old_Value)>>2);

if(current_value<Old_Value) Old_Value=Old_Value-((Old_Value-current_value)>>2);
return Old_Value;

we usually use the following: we get extra bits of precision:

return (Old_Value * 3 + current_value) >> 2;

Here is useful tool for example filtering measured boost pressure.

Both of them had same problem: boost was fluctuating +- 5 kPa around target.

Possible reasons

Any more info and logs ?

So here is an idea: direct mechanical control of wastegate,using RC-servos, or linear positionable actuators. Even though it is possible, it is a good idea to use the pressure (which is there for free) and tiny air-valve(s) for actuation instead of huge, expensive and troublesome servos.

Precision improvement this is commited to CVS head but (since the head is not for production at the moment) must be applied to older revisions manually (patch command).

RCS file: /cvsroot/megasquirtavr/firmware/ve.c,v
retrieving revision 1.117
retrieving revision 1.118
diff -r1.117 -r1.118
<   uint16_t rpm_weight, kpa_weight, rpm_weight255, kpa_weight255;
>   uint16_t rpm_weight, kpa_weight;    // weight for upper index
>   uint16_t rpm_weight255, kpa_weight255;      // weight for lower index
<       w_21 = t_21 * (rpm_weight >> 8);
<       w_22 = t_22 * (rpm_weight255 >> 8);
<       // take care of overflow (price is cycles. >>8 before addition would cost precision):
<       engine.boostmax_target = ( (w_21 >> 4) + (w_22 >> 4) )>>4;
>       w_21 = div4096( mult16_8( rpm_weight255, t_21 ) );
>       w_22 = div4096( mult16_8( rpm_weight, t_22 ) );
>       engine.boostmax_target = ( w_21 + w_22 ) >> 4;

if using patch command sounds too complex (it is not) you can just change the #ifdef BOOSTCONTROL .. #endif part in ve.c to:

	// TODO: add gear selection
#define BOOSTGEAR 0
	t_21 = boostmaxtarget_table[ BOOSTGEAR * VE_SIZE_RPM + rpm_idx.lindex ];
	t_22 = boostmaxtarget_table[ BOOSTGEAR * VE_SIZE_RPM + rpm_idx.uindex ];
	w_21 = div4096( mult16_8( rpm_weight255, t_21 ) );
	w_22 = div4096( mult16_8( rpm_weight, t_22 ) );
	engine.boostmax_target = ( w_21 + w_22 ) >> 4;

Boost-transfer function learning

Many people claim that most boostcontrollers don't work well. It probably means that very few controllers do proper auto-learning. And it's definitely not easy to tune the parameters manually. Also, the importance of the "fixed restriction" sizing is often neglected.

We should implement some autolearning (maybe with PC-assist) to provide a useful system for non-experts who cannot tune properly, and would claim that "ain't work".

It looks somewhat more complex than VE autolearn (which has been implemented for ages).

The convergent behaviour is the simple part. With any PWM-duty, the boost will not raise above a certain value for long. Eg. 0% => 40kPa, 100% => 120kPa (almost linear). The hard part is the transient behavior. Even the transient behaviour model is relatively simple (assuming sufficient precision, of course) but measuring some constant parameters of the model is hard.

A good question is if PID control is good enough or not. PID is good for linear system. PID is suboptimal for systems that involve saturation (nonlinearity). The flying characteristics of the F16 fighter significantly improved when they patched the PID control (with a few lines?) to consider saturation.