MODULAR PNEUMATICS SYSTEM INFORMATION

The information on this page is related to the modular pneumatics system, as defined in the [PNEUMATIC_SYSTEM_EX1] section of the systems.cfg file.

NOTE: This section is required for all modern aircraft, and only legacy Microsoft Flight Simulator 2020 aircraft should use the less comprehensive [PNEUMATIC_SYSTEM] section.

The pneumatic system gathers air flow coming from the engines (bleed air) or opening in the aircraft (ram air) and runs this air through its lines and components like packs or mixer units to bring it to the area(s) where it is required. Some of the air flow can loop back to the mixer units in the case of airliners.

To simplify the management of the system and avoid unnecessary calculations, air is always considered as going through the entirety of a line and it will never be stopped by other air flow. For example, if there are two output lines on a junction but one of them goes nowhere, the air flow will still be divided between both those lines. Or, if two air-flows go through each end of the same line, both will journey through it and go on to the attached components. You can find some examples to get a better understanding of how everything works from the following page:

• Pneumatic System Examples

Air flow status (temperature, pressure, volume) is calculated at each air flow processing component. These are components that gather all the flow input they received and combine all of it into a new airflow to be sent further along in the system.

For additional information on creating a functioning pneumatic system, please see the following page:

• Pneumatic System Setup Information

The different source components are as follows:

• APU: An auxiliary source of power providing airflow to turn on the engines or airflow to the main system in case of emergency.
• Engine: Primary engine providing air flow to the system.
• RamAir: A source of air flow that is based on the aircraft speed.

The different temperature/pressure components are as follows:

• Pack: This component takes the bleed air coming from the engines and cools it.
• MixerUnit: This component receives all the air flow coming from the packs, ram air, and the loop coming back from the areas, and then mixes them all together before sending the result into the areas.

The different consumer components are as follows:

• Area: A zone of the aircraft into which air will be routed (cockpit, cabin, etc…).
• Outlet: This component allows other systems to be fed air from the pneumatic system. These are systems that might be using air flow as a primary power source or as an emergency one, like wing deicing or brakes.

The different connection components are as follows:

• Junction: A junction forms a crossroad for various lines to go through.
• Line: These define how all the components listed above are linked to one another.

The different Line Features are as follows:

• Valve: This line feature will limit the air flow going through it.
• Fan: This line feature is used to create pressure difference (and thus, flow) in a line.

There is also the following data component that is used by some of the other components:

• Curve: Used to define the engine temperature output(s).

Many of these components can be checked using SimVars, and you can find information about those here:

• Pneumatics

Finally, it should be noted that there are some parameters that can be set in the FLT file to initialise the pneumatic system to specific values for a flight or a mission. You can find more information here:

• [PNEUMATIC_SYSTEM_EX1.N]

APU.N

The APU is an auxiliary engine that provides airflow to the other engines or to the pneumatic system in case of emergency. Each APU has an index, starting from 1, and is created as a hash map comprised of the following multiple key:value pairs, separated by the # symbol:

APU.N = Name:<apu_name> #BleedTemperaturesCurve:<curve_name> #OutputFlow:<flow_m3>

Note that you may have more than one APU in a system. In these cases you would add further APU components and increment the N index, starting from 1. A full example of a single APU definition would be like this:

APU.1 = Name:APU #BleedTemperaturesCurve:1 #OutputFlow:3.0

Engine.N

This defines a primary engine providing air flow to the pneumatic system. Each engine is created as a hash map comprised of the following multiple key:value pairs, separated by the # symbol:

Engine.N = Name:<engine_name> #Index:<engine_index> #BleedTemperaturesCurve:<curve_name> #OutputFlow:<flow_m3>

Note that you may have more than one engine, so for each one you should increment the N index, starting from 1. A full example of a single engine definition would be like this:

Engine.1 = Name:LeftEngine#Index:1 #BleedTemperaturesCurve:2 #OutputFlow:3.0

RamAir.N

This defines a source of air flow from the aircraft exterior which will vary with the aircraft speed. Each ram air component is created as a hash map comprised of the following multiple key:value pairs, separated by the # symbol:

RamAir.1 = Name:<ramair_name> #Surface:<area_m2>

Note that you may have more than one ram air component, so for each one you should increment the N index, starting from 1. A full example of a single ram air definition would be like this:

RamAir.1 = Name:RamAir #Surface:0.1

Pack.N

This component takes the bleed air coming from the engines and cools it, and you normally have as many packs as you have primary engines. Each pack is created as a hash map comprised of the following multiple key:value pairs, separated by the # symbol:

Pack.N = Name:<pack_name> #Circuit:<circuit_index> #TypicalFlow:<flow_m3> #MinTemperatureOutput:<mintemp_C> #MaxTemperatureOutput:<maxtemp_C> #DefaultTemperatureOutput:<defaulttemp_C> #PackFlowLow:<low_pct> #PackFlowNorm:<med_pct> #PackFlowHigh:<high_pct> #ManagedAreas:<area_1>, <area_2>, <...>

Note that you may have more than one pack, so for each one you should increment the N index, starting from 1. A full example of a single pack definition would be like this:

Pack.1 = Name:LeftPack #Circuit:1 #TypicalFlow:0.2 #DefaultTemperatureOutput:24 #PackFlowHigh:1.3

MixerUnit.N

The mixer unit is the component receiving all the air flow coming from the Packs, Ram Air, and the loop coming back from the Areas, and mixing them all together and sending the result into the areas again. Each mixer unit is created as a hash map comprised of the following multiple key:value pairs, separated by the # symbol:

MixerUnit.N = Name:<mixerunit_name>

Note that you may have more than one mixer unit, so for each one you should increment the N index, starting from 1. A full example of a single mixer unit definition would be like this:

MixerUnit.1 = Name:MixerUnit

Area.N

An area is simply zone within the aircraft to which the airflow will be routed, for example the cockpit, the cabin, etc... Each area is created as a hash map comprised of the following multiple key:value pairs, separated by the # symbol:

Area.N = Name:<area_name> #Volume:<vol_m3> #Bleed:<area_index>,<flow>:<area_index>,<flow>:<etc...> #AmbientBleedStaticFlow:<flow_m3> #OpeningIndices: <point.1>, <point.2>, <etc...> #OpeningNames: <point_name.1>, <point_name.2>, <etc...> #PID:<p>,<i>,<d>

Note that you may have more than one actuator, so for each one you should increment the N index, starting from 1. A full example of a single actuator definition would be like this:

Area.1 = Name:Cockpit #Volume:10 #Bleed:1,0.2:3,0.5 #Ambientbleedbaseflow:0.1

#Bleed:1,0.2:3,0.5

Outlet.N

The outlet component allows other systems to be fed air by the pneumatic system. This concerns any system that might be using airflow as a primary power source or as an emergency one, for example wing deicing or brakes. Each outlet is created as a hash map comprised of the following multiple key:value pairs, separated by the # symbol:

Outlet.N = Name:<outlet_name> #Type:<type> #OutletID:<integer_id>

Note that you may have more than one outlet, so for each one you should increment the N index, starting from 1. A full example of a single outlet definition would be like this:

Outlet.1 = Name:WingsDeice #Type:WingDeice #MaxPSI:3.1

Valve.N

The valve line feature is used to limit the airflow and is referenced in the different Line components.

IMPORTANT! All line valve types are used as part of the Line component except the Outflow Valve. This valve is considered a component in its own right, so when it is assigned to a line, it is not a "feature" but rather an output component at one end of the line.

Each valve is created as a hash map comprised of the following multiple key:value pairs, separated by the # symbol:

Valve.N = Name:<line_name> #Circuit:<circuit_name> #ManagedArea:<area_name> #OpeningTime:<secs> #Type:<type>

Note that you may have more than one valve, so for each one you should increment the N index, starting from 1. A full example of a single valve definition would be like this:

Valve.1 = Name:OutflowValve #Circuit:1 #Type:Outflow #OpeningTime:3.0

Finally, it should be mentioned that valves also have modes that are not set using the CFG files, but instead are changed during the simulation based on conditions and pilot input. See here for more information:

• Valve Modes

Fan.N

The fan line feature is used to create pressure difference inside a Line component. Each fan is created as a hash map comprised of the following multiple key:value pairs, separated by the # symbol:

Fan.N = Name:<line_name> #Circuit:<circuit_index> #SpeedUpTime:<seconds> #StaticPressure:<pressure> #MaxFlow:<flow_m3>

Note that you may have more than one fan, so for each one you should increment the N index, starting from 1. A full example of a single fan definition would be like this:

Fan.1 = Name:TheFan #Circuit:17 #SpeedUpTime:1.0 #StaticPressure:1.0 #MaxFlow:6.0

Junction.N

A junction is simply a crossroad for different Line components to go through. By default, lines that are connected to a junction can be taken as both input and output, essentially being two-way lines within the system. Each junction is created as a hash map comprised of the following multiple key:value pairs, separated by the # symbol:

Junction.N = Name:<junction_name> #InputOnlyLines:<line_1>,<line_2>,<etc...> #OutputOnlyLines:<line_1>,<line_2>,<etc...>

Note that you may have more than one junction, so for each one you should increment the N index, starting from 1. A full example of a single junction definition would be like this:

Junction.2 = Name:RightJunction #OutputOnlyLines:RightJunctionToEnginesHotAirJunction,RightJunctionToRightPack

Line.N

The line component define how all the components within a hydraulic system are linked to one another. Each line is created as a hash map comprised of the following multiple key:value pairs, separated by the # symbol:

Line.N = Name:<line_name> #Source:<input_component> #Destination:<output_component> #MaxFlow:<flow_m3> #Valves:<valve_name1>,<valve_name2>,etc... #Fan:<fan_name>

Note that you may have more than one line, so for each one you should increment the N index, starting from 1. A full example of a single line definition would be like this:

Line.1 = Name:APUToLeftJunction #Source:APU #Destination:LeftJunction #Valves:Valve1 #Fan:FlowFan

Curve.N

The curve data component is simply a way of defining an Engine (or APU) temperature output curve once, and being able to use it in multiple places (thus removing the need to duplicate data in multiple places). Each curve is created as a list of two values separated by a comma:

Curve.N = <value_temp>:<value_rpm>, <value_temp>:<value_rpm>, ...

The values used here represent the following:

Note that you may have more than one curve, so for each one you should increment the N index, starting from 1. A full example of a single curve definition would be like this:

Curve.1 = 0:200, 100:220