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.
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:
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:
For debugging tools related to the pnuematic system, please see the following page:
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.
- ExternalUnit.N: An external unit that provides air flow to the system.
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:
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> #Volume:<vol_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| Key | Value | Description | Required |
|---|---|---|---|
Name | String | This is a name string that is used as an alias to identify the APU. It will also be used as the reference index for SimVars, and note that the name is the only guaranteed reference to the component due to the fact that the Modular Aircraft Merging process may change the index. | Yes |
BleedTemperaturesCurve | Curve | The index of the Curve used to determine the temperature output of the APU in relation to its RPM. | Yes |
OutputFlow | Float | The amount of air flow going out of the APU, in m³/second. | Yes |
Volume | Float | The total volume of air (in m³) that the APU can contain. Larger volumes will require longer times to build up air pressure. Default value is 1. | No |
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> #Volume:<vol_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| Key | Value | Description | Required |
|---|---|---|---|
Name | String | This is a name string that is used as an alias to identify the engine. It will also be used as the reference index for SimVars, and note that the name is the only guaranteed reference to the component due to the fact that the Modular Aircraft Merging process may change the index. | Yes |
Index | Integer | This is the index of the aircraft engine that the component refers to. Generally going from left to right, 1 to 16. | Yes |
BleedTemperaturesCurve | Curve | The index of the Curve used to determine the temperature output of the engine in relation to its RPM. | Yes |
OutputFlow | Float | The amount of air flow going out of the engine, in m³/second. | Yes |
Volume | Float | The total volume of air (in m³) that the engine can contain. Larger volumes will require longer times to build up air pressure. Default value is 1. | No |
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> #Volume:<vol_m3>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| Key | Value | Description | Required |
|---|---|---|---|
Name | String | This is a name string that is used as an alias to identify the RamAir input. It will also be used as the reference index for SimVars, and note that the name is the only guaranteed reference to the component due to the fact that the Modular Aircraft Merging process may change the index. | Yes |
Surface | Float | The surface area (in m²) dedicated to air intake. The wind speed and ambient pressure combined with the given intake surface area dictates how much flow the ram air pushes into the system. Default value is 0.05 (m²). | No |
Volume | Float | The total volume of air (in m³) that the ram air scoop can contain. Larger volumes will require longer times to build up air pressure. Default value is 1. | No |
ExternalUnit.N
This defines a source of air flow that is external to the aircraft. Each external unit component is created as a hash map comprised of the following multiple key:value pairs, separated by the # symbol:
ExternalUnit.1 = Name:<unit_name> #OutputPressure:<pressure_psi> #OutputFlow:<flow_m3/s> #OutputTemperature:<temp_degrees> #InteractivePointName:<point_name>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:
ExternalUnit.1 = Name:AirStartUnit #OutputPressure:42 #OutputFlow:3.0 #OutputTemperature:200.0 #InteractivePointName:ASU| Key | Value | Description | Required |
|---|---|---|---|
Name | String | This is a name string that is used as an alias to identify the External Unit. It will also be used as the reference index for SimVars, and note that the name is the only guaranteed reference to the component due to the fact that the Modular Aircraft Merging process may change the index. | Yes |
OutputPressure | Float | The pressure of the air going out of the external unit, expressed in psi. Default value is 42 (psi). | No |
OutputTemperature | Float | The temperature of the air flowing out of the external unit, in degrees. Default value is 200. | No |
OutputFlow | Float | The amount of air flow going out of the external unit, expressed as m³ per second. Default value is 3.0 (m³ / s). | No |
InteractivePointName | String | This is the name of the interactive point (see [INTERACTIVE POINTS] for more information) which will be the location of the input flow from the external unit. Note that the interactive point must be of the type Air Start Unit (5). | Yes |
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> #Volume:<vol_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| Key | Value | Description | Required |
|---|---|---|---|
Name | String | This is a name string that is used as an alias to identify the pack. It will also be used as the reference index for SimVars, and note that the name is the only guaranteed reference to the component due to the fact that the Modular Aircraft Merging process may change the index. | Yes |
Circuit | Integer | The index of the electrical Circuit powering the pack. The circuit must be of the CIRCUIT_PNEUMATICS_PACK type, and it's one circuit per-pack as you cannot control multiple packs off a single circuit. | Yes |
TypicalFlow | Float | This is the nominal input flow of the pack, usually the bleed air flow of its associated engine, in m³/second. | Yes |
Volume | Float | The total volume of air (in m³) that the pack can contain. Larger volumes will require longer times to build up air pressure. Default value is 1. | No |
MinTemperatureOutput | Float | The default temperature in °C that the pack outputs. Default value is 8. | No |
MaxTemperatureOutput | Float | The lowest temperature in °C that the pack can go to refresh the connected areas. Default value is 50. | No |
DefaultTemperatureOutput | Float | The highest temperature in °C that the pack can go to heat the connected areas. NOTE: If this is defined for 1 pack, it must be defined for ALL packs. Default value is 0. | No |
PackFlowLow | Float | The amount of bleed air taken from the engines when on the lowest setting, expressed as a Percent Over 100. Default value is 0.8. | No |
PackFlowNorm | Float | The amount of bleed air taken from the engines when on the normal setting, expressed as a Percent Over 100. Default value is 1.0. | No |
PackFlowHigh | Float | The amount of bleed air taken from the engines when on the highest setting, expressed as a Percent Over 100. Default value is 1.2. | No |
ManagedAreas | List (Strings) | The specific area (or areas) that this pack should be servicing. The parameter requires one or more Area names to associate the pack with those areas. If this parameter is omitted from the hashmap then the pack will service all areas. | No |
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> #Volume:<vol_m3>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| Key | Value | Description | Required |
|---|---|---|---|
Name | String | This is a name string that is used as an alias to identify the Mixer Unit. It will also be used as the reference index for SimVars, and note that the name is the only guaranteed reference to the component due to the fact that the Modular Aircraft Merging process may change the index. | Yes |
Volume | Float | The total volume of air (in m³) that the mixer unit can contain. Larger volumes will require longer times to build up air pressure. Default value is 1. | No |
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| Key | Value | Description | Required |
|---|---|---|---|
Name | String | This is a name string that is used as an alias to identify the area. It will also be used as the reference index for SimVars, and note that the name is the only guaranteed reference to the component due to the fact that the Modular Aircraft Merging process may change the index. | Yes |
Volume | Float | The approximate total volume for the area, in m³. | Yes |
Bleed | 2D Array (Integer, Float) | This defines the amount of air coming out of the area and going into another one. This is a required parameter as areas are not normally hermetically sealed, which means that the temperature of one will affect the temperature of the others that are close to it or connected to it in some way. Note that this part of the pneumatic system is bi-directional, so if you create - for example - bleed from Area 1 into Area 2, you will not need to define the bleed from Area 2 into Area 1, as the simulation will already do this. Bleed is created as an array with the following format: Bleed:<area_index>,<flow>:<area_index>,<flow>:<etc...> The two values represent:
An example of a typical bleed definition would be like this: | Yes |
AmbientBleedStaticFlow | Float | This parameter defines the minimum amount of airflow coming into the area from external sources - other than ram air - when the aircraft is stopped or moving slowly. It represents the fact that an area is not hermetically sealed to the outside and so some air from outside is being circulated into the system. Value is in m³/second. Note that ambient bleed will be constant, regardless of the airspeed. | Yes |
OpeningIndices | List (Integers) | This parameter is used to supply one or more Note that this method for identifying an interactive point is not reliable due to the way the Modular SimObject Merging process works and so you should be supplying a | No |
OpeningNames | List (Strings) | This parameter is used to supply one or more Note that this is the preferred method for identifying an interactive point, but if you have supplied one or more | No |
PID | List (3 Floats) | This is only used if the pneumatic system being defined has one or more Packs. You give a list of 3 values defining the PID values to use to control the automated system that will use the packs to keep the aircraft cool. Default values are: 0.005, 0.05, 0.1. | No |
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:<name> #Type:<type> #ConsumptionVolume:<cVol_m3> #ConsumptionPressure:<cPres_psi> #ConsumptionTemperature:<cTemp_deg> #Index:<index> #Volume:<vol_m3>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| Key | Value | Description | Required |
|---|---|---|---|
Name | String | This is a name string that is used as an alias to identify the outlet. It will also be used as the reference index for SimVars, and note that the name is the only guaranteed reference to the component due to the fact that the Modular Aircraft Merging process may change the index. | Yes |
Type | String | The type of system that the outlet is to target, which can be one of the following:
| No |
ConsumptionVolume | Float | The volume of air flow - expressed in m³ - required by the outlet to function properly. Default value is 1. | No |
ConsumptionPressure | Float | The air flow pressure required by the outlet to function properly, expressed in psi. Default value is 14.5. | No |
ConsumptionTemperature | Float | The temperature of the air flow - expressed in °C - required by the outlet to function properly. Default value is 15. | No |
Index | Integer | This key is only required if the Type key is "Starter" and the value given here defines the index of the aircraft engine that the output refers to. Generally going from left to right, 1 to 16. | No (Yes, if the |
Volume | Float | The total volume of air (in m³) that the outlet can contain. Larger volumes will require longer times to build up air pressure. Default value is 1. | No |
Valve.N
The valve line feature is used to limit the airflow and is referenced in the different Line components.
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.0Finally, 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:
| Key | Value | Description | Required |
|---|---|---|---|
Name | String | This is a name string that is used as an alias to identify the valve. It will also be used as the reference index for SimVars, and note that the name is the only guaranteed reference to the component due to the fact that the Modular Aircraft Merging process may change the index. | Yes |
Circuit | Integer | This is the index of the electrical Circuit powering the valve. Note that the circuit needs to be of the type CIRCUIT_PNEUMATICS_VALVE, and it's one circuit per-valve as you cannot control multiple valves off a single circuit. | Yes |
ManagedArea | String | The name of the Area managed by the valve. In the case of temperature selection in the managed area, a valve will have the job to regulate the amount of hot air mixing with the cold air coming from the mixer unit and going into the area. Default value is "". | No |
OpeningTime | Float | This is the amount of time needed for the valve to go from fully closed to fully open, in seconds. The default value is 0.5. | No |
Type | String | This defines the type of valve that is being used. Note that you can only have one valve of a specific type in an aircraft except the generic valve. The available valve types are:
The default value is “Generic”. | No |
PID | List (3 Floats) | This is only used if the valve being defined is connected to a managed Area. You give a list of 3 values defining the PID values to use to control the automated system that will use the valve to keep the area warm. Default values are: 0.10008, 0.008, 0.01. | No |
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| Key | Value | Description | Required |
|---|---|---|---|
Name | String | This is a name string that is used as an alias to identify the fan. It will also be used as the reference index for SimVars, and note that the name is the only guaranteed reference to the component due to the fact that the Modular Aircraft Merging process may change the index. | Yes |
Circuit | Integer | This is the index of the electrical Circuit powering the fan. Note that the circuit needs to be of the type CIRCUIT_PNEUMATICS_FAN. | Yes |
SpeedUpTime | Float | This defines the time it takes for the fan to go from 0% speed to 100% speed. The time is given in seconds. Default value is 2. | No |
StaticPressure | Float | This is the pressure that exists without any flow, expressed in kilopascal (kPa). Default value is 3. | No |
MaxFlow | Float | This defines the flow at which the fan will not create any pressure. If the flow rate is above this value, then the fan will actually decrease it. Value is in m³/second. Default value is 3. | No |
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...> #Volume:<vol_m3>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| Key | Value | Description | Required |
|---|---|---|---|
Name | String | This is a name string that is used as an alias to identify the junction. It will also be used as the reference index for SimVars, and note that the name is the only guaranteed reference to the component due to the fact that the Modular Aircraft Merging process may change the index. | Yes |
InputOnlyLines | Array (Strings) | This is a comma separated array that is used to add one or more line(s) which input into the junction being defined. | No |
OutputOnlyLines | Array (Strings) | This is a comma separated array that is used to define the line(s) that the junction being defined will output to. | No |
Volume | Float | The total volume of air (in m³) that the junction can contain. Larger volumes will require longer times to build up air pressure. Default value is 1. | No |
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> #Volume:<vol_m3>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| Key | Value | Description | Required |
|---|---|---|---|
Name | String | This is a name string that is used as an alias to identify the line. It will also be used as the reference index for SimVars, and note that the name is the only guaranteed reference to the component due to the fact that the Modular Aircraft Merging process may change the index. | Yes |
Source | String | The name of the source component that the line is coming from. | Yes |
Destination | String | The name of the destination component that the line is going to. | Yes |
MaxFlow | Float | This is the maximum amount of airflow that can go through the line. This can serve as a limiter for the system so that it's destination components are not overwhelmed with air flow (but shouldn't really be needed if the system is well designed and calibrated). Value is in m³/second. If this parameter is not included then the line is considered as being unlimited. | No |
Valves | Array (Strings) | This is a comma separated array of Valve names that are on the line being defined. | No |
Fan | String | This is the name of a Fan that is part of the line being defined. | No |
Volume | Float | The total volume of air (in m³) that the APU can contain. Larger volumes will require longer times to build up air pressure. Default value is 1. | No |
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:
| Key | Value | Description | Required |
|---|---|---|---|
value_temp | Float | This is a temperature, in °C. | Yes |
value_rpm | Float | This is the engine RPM that corresponds to the given temperature. | Yes |
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