> For the complete documentation index, see [llms.txt](https://support.powerio.com/hub/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://support.powerio.com/hub/codesys-hvac/en/hvac-modbus-library/functionblocks/systemair/systemair_save_control.md).

# SYSTEMAIR\_SAVE\_CONTROL

## `SYSTEMAIR_SAVE_CONTROL` (FB)

`FUNCTION_BLOCK` SYSTEMAIR\_SAVE\_CONTROL

### Representation

<figure><img src="/files/1e571ff7bbd77031669c5252120962c14aa43031" alt=""><figcaption></figcaption></figure>

InOut:

| Scope       | Name                  | Type                                               | Initial                                                   | Comment                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| ----------- | --------------------- | -------------------------------------------------- | --------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Input       | `xEn`                 | `BOOL`                                             | TRUE                                                      | Enable / disable communication (TRUE = enable)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Input       | `byUnitId`            | `BYTE`                                             | 0                                                         | Device address                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Input       | `xUpdateActual`       | `BOOL`                                             | FALSE                                                     | <p>Update of actual values (on every rising edge<br>)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Input       | `xUpdateSetp`         | `BOOL`                                             | FALSE                                                     | <p>Update of setpoints (on every rising edge<br>)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Input       | `eOpMode`             | SYSTEMAIR\_SAVE\_CONTROL\_OP\_MODE                 | SYSTEMAIR\_SAVE\_CONTROL\_OP\_MODE.AUTO                   | Operating mode of the device — preset                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Input       | `arwSpFan_Percent`    | `ARRAY` \[1 .. 10] `OF` `WORD`                     | \[16, 16, 16, 16, 16, 16, 16, 16, 16, 16]                 | <p>Setpoints (percent) of the fans in the individual fan stages (MIN, LOW, NORMAL, HIGH, MAX)<br>arwSpFan\_Percent\[1] = Setpoint - supply fan at stage MIN (range: 16 … 100)<br>arwSpFan\_Percent\[2] = Setpoint - exhaust fan at stage MIN (range: 16 … 100)<br>arwSpFan\_Percent\[3] = Setpoint - supply fan at stage LOW (range: 16 … 100)<br>arwSpFan\_Percent\[4] = Setpoint - exhaust fan at stage LOW (range: 16 … 100)<br>arwSpFan\_Percent\[5] = Setpoint - supply fan at stage NORMAL (range: 16 … 100)<br>arwSpFan\_Percent\[6] = Setpoint - exhaust fan at stage NORMAL (range: 16 … 100)<br>arwSpFan\_Percent\[7] = Setpoint - supply fan at stage HIGH (range: 16 … 100)<br>arwSpFan\_Percent\[8] = Setpoint - exhaust fan at stage HIGH (range: 16 … 100)<br>arwSpFan\_Percent\[9] = Setpoint - supply fan at stage MAX (range: 16 … 100)<br>arwSpFan\_Percent\[10] = Setpoint - exhaust fan at stage MAX (range: 16 … 100)</p>                         |
| Input       | `arwSpFan_UPM`        | `ARRAY` \[1 .. 10] `OF` `WORD`                     | \[500, 500, 500, 500, 500, 500, 500, 500, 500, 500]       | <p>Setpoints (RPM) of the fans in the individual fan stages (MIN, LOW, NORMAL, HIGH, MAX)<br>arwSpFan\_UPM\[1] = Setpoint - supply fan at stage MIN (range: 500 … 5000)<br>arwSpFan\_UPM\[2] = Setpoint - exhaust fan at stage MIN (range: 500 … 5000)<br>arwSpFan\_UPM\[3] = Setpoint - supply fan at stage LOW (range: 500 … 5000)<br>arwSpFan\_UPM\[4] = Setpoint - exhaust fan at stage LOW (range: 500 … 5000)<br>arwSpFan\_UPM\[5] = Setpoint - supply fan at stage NORMAL (range: 500 … 5000)<br>arwSpFan\_UPM\[6] = Setpoint - exhaust fan at stage NORMAL (range: 500 … 5000)<br>arwSpFan\_UPM\[7] = Setpoint - supply fan at stage HIGH (range: 500 … 5000)<br>arwSpFan\_UPM\[8] = Setpoint - exhaust fan at stage HIGH (range: 500 … 5000)<br>arwSpFan\_UPM\[9] = Setpoint - supply fan at stage MAX (range: 500 … 5000)<br>arwSpFan\_UPM\[10] = Setpoint - exhaust fan at stage MAX (range: 500 … 5000)</p>                                                 |
| Input       | `arwSpFan_Pressure`   | `ARRAY` \[1 .. 10] `OF` `WORD`                     | \[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]                           | <p>Setpoints (pressure) of the fans in the individual fan stages (MIN, LOW, NORMAL, HIGH, MAX)<br>arwSpFan\_Pressure\[1] = Setpoint - supply fan at stage MIN (range: unknown)<br>arwSpFan\_Pressure\[2] = Setpoint - exhaust fan at stage MIN (range: unknown)<br>arwSpFan\_Pressure\[3] = Setpoint - supply fan at stage LOW (range: unknown)<br>arwSpFan\_Pressure\[4] = Setpoint - exhaust fan at stage LOW (range: unknown)<br>arwSpFan\_Pressure\[5] = Setpoint - supply fan at stage NORMAL (range: unknown)<br>arwSpFan\_Pressure\[6] = Setpoint - exhaust fan at stage NORMAL (range: unknown)<br>arwSpFan\_Pressure\[7] = Setpoint - supply fan at stage HIGH (range: unknown)<br>arwSpFan\_Pressure\[8] = Setpoint - exhaust fan at stage HIGH (range: unknown)<br>arwSpFan\_Pressure\[9] = Setpoint - supply fan at stage MAX (range: unknown)<br>arwSpFan\_Pressure\[10] = Setpoint - exhaust fan at stage MAX (range: unknown)</p>                        |
| Input       | `arwSpFan_VolumeFlow` | `ARRAY` \[1 .. 10] `OF` `WORD`                     | \[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]                           | <p>Setpoints (volume flow) of the fans in the individual fan stages (MIN, LOW, NORMAL, HIGH, MAX)<br>arwSpFan\_VolumeFlow\[1] = Setpoint - supply fan at stage MIN (range: unknown)<br>arwSpFan\_VolumeFlow\[2] = Setpoint - exhaust fan at stage MIN (range: unknown)<br>arwSpFan\_VolumeFlow\[3] = Setpoint - supply fan at stage LOW (range: unknown)<br>arwSpFan\_VolumeFlow\[4] = Setpoint - exhaust fan at stage LOW (range: unknown)<br>arwSpFan\_VolumeFlow\[5] = Setpoint - supply fan at stage NORMAL (range: unknown)<br>arwSpFan\_VolumeFlow\[6] = Setpoint - exhaust fan at stage NORMAL (range: unknown)<br>arwSpFan\_VolumeFlow\[7] = Setpoint - supply fan at stage HIGH (range: unknown)<br>arwSpFan\_VolumeFlow\[8] = Setpoint - exhaust fan at stage HIGH (range: unknown)<br>arwSpFan\_VolumeFlow\[9] = Setpoint - supply fan at stage MAX (range: unknown)<br>arwSpFan\_VolumeFlow\[10] = Setpoint - exhaust fan at stage MAX (range: unknown)</p> |
| Input       | `rSpTemp`             | `REAL`                                             | 22.0                                                      | <p>Setpoint - temperature (supply air, exhaust air, room) (range:<br>12.0 - 30.0 degrees Celsius)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Input       | `rSpSupplyTempMin`    | `REAL`                                             | 18.0                                                      | <p>Minimum value - supply air temperature (range: 12.0 - 40.0 degrees<br>Celsius)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Input       | `rSpSupplyTempMax`    | `REAL`                                             | 30.0                                                      | <p>Maximum value - supply air temperature (range: 12.0 - 40.0 degrees<br>Celsius)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Input       | `xFilterReset`        | `BOOL`                                             | FALSE                                                     | State of filter reset (TRUE = active)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Input       | `xResError`           | `BOOL`                                             | FALSE                                                     | <p>Reinitialization of the outputs <code>eErrorCodeCom</code> in the<br>fault-free state (on each rising edge)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Inout       | `ModbusClient`        | `ModbusClientBase`                                 |                                                           | Client of the device                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| Output      | `eOpModeFb`           | SYSTEMAIR\_SAVE\_CONTROL\_OP\_MODE\_FB             |                                                           | Operating mode of the device — feedback                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Output      | `xOperation`          | `BOOL`                                             |                                                           | Operating message of the device (TRUE = operation)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Output      | `rSpSupplyFan_Min`    | `REAL`                                             |                                                           | <p>Setpoint - supply fan at stage Minimum (percent,<br>RPM, pressure, volume flow)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| Output      | `rSpExhausFan_Min`    | `REAL`                                             |                                                           | <p>Setpoint - exhaust fan at stage Minimum (percent,<br>RPM, pressure, volume flow)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Output      | `rSpSupplyFan_Low`    | `REAL`                                             |                                                           | <p>Setpoint - supply fan at stage Low (percent,<br>RPM, pressure, volume flow)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Output      | `rSpExhausFan_Low`    | `REAL`                                             |                                                           | <p>Setpoint - exhaust fan at stage Low (percent,<br>RPM, pressure, volume flow)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Output      | `rSpSupplyFan_Nor`    | `REAL`                                             |                                                           | <p>Setpoint - supply fan at stage Normal (percent,<br>RPM, pressure, volume flow)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Output      | `rSpExhausFan_Nor`    | `REAL`                                             |                                                           | <p>Setpoint - exhaust fan at stage Normal (percent,<br>RPM, pressure, volume flow)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| Output      | `rSpSupplyFan_Hig`    | `REAL`                                             |                                                           | <p>Setpoint - supply fan at stage High (percent,<br>RPM, pressure, volume flow)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Output      | `rSpExhausFan_Hig`    | `REAL`                                             |                                                           | <p>Setpoint - exhaust fan at stage High (percent,<br>RPM, pressure, volume flow)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| Output      | `rSpSupplyFan_Max`    | `REAL`                                             |                                                           | <p>Setpoint - supply fan at stage Maximum (percent,<br>RPM, pressure, volume flow)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| Output      | `rSpExhausFan_Max`    | `REAL`                                             |                                                           | <p>Setpoint - exhaust fan at stage Maximum (percent,<br>RPM, pressure, volume flow)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Output      | `rRotSpeedSupFan`     | `REAL`                                             |                                                           | <p>Current speed of the supply fan in 1 / min (<br>tachometer signal, 0 - 5000)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Output      | `rRotSpeedExhFan`     | `REAL`                                             |                                                           | <p>Current speed of the exhaust fan in 1 / min (<br>tachometer signal, 0 - 5000)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| Output      | `rSpSupplyAirTemp`    | `REAL`                                             |                                                           | Current supply air set temperature (12.0 - 30.0 degrees Celsius)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Output      | `rAntifreezeSig`      | `REAL`                                             |                                                           | Actual value - frost protection sensor (-40.0 - +80.0 degrees Celsius)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| Output      | `rTempOda`            | `REAL`                                             |                                                           | Current outside temperature (-40.0 - +80.0 degrees Celsius)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| Output      | `rSupplyAirTemp`      | `REAL`                                             |                                                           | Current supply air temperature (-40.0 - +80.0 degrees Celsius)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Output      | `rRoomTemp`           | `REAL`                                             |                                                           | Current room temperature (-40.0 - +80.0 degrees Celsius)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Output      | `rOverHeatTemp`       | `REAL`                                             |                                                           | <p>Current overheating temperature in the electric<br>post-heating coil (-40.0 - +80.0 degrees Celsius)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| Output      | `rExhaustAirTemp`     | `REAL`                                             |                                                           | Current exhaust air temperature (-40.0 - +80.0 degrees Celsius)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| Output      | `rContSigHeatRec`     | `REAL`                                             |                                                           | Control signal - HRU or bypass (0 - 100%)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Output      | `rContSigReHeat`      | `REAL`                                             |                                                           | Control signal - post-heating coil (0 - 100%)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Output      | `xFilterMainten`      | `BOOL`                                             |                                                           | <p>Actual value - filter maintenance indicator (TRUE = maintenance required<br>)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| Output      | `xFireAlarm`          | `BOOL`                                             |                                                           | Actual value - fire alarm (smoke detector) (TRUE = alarm active)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Output      | `xErrorDevice_A`      | `BOOL`                                             |                                                           | <p>Alarm output - fault messages - Alarm A (TRUE = fault<br>active)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Output      | `xErrorDevice_B`      | `BOOL`                                             |                                                           | <p>Alarm output - fault messages - Alarm B (TRUE = fault<br>active)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Output      | `xErrorDevice_C`      | `BOOL`                                             |                                                           | <p>Alarm output - fault messages - Alarm C (TRUE = fault<br>active)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Output      | `xAlarm`              | `BOOL`                                             | FALSE                                                     | Collective fault (TRUE = fault)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| Output      | `xAlarmCom`           | `BOOL`                                             | FALSE                                                     | Collective fault - communication (TRUE = fault)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| Output      | `eErrorCodeCom`       | ModbusErrorCode                                    |                                                           | Error code - communication (0 = no error)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Output      | `xBusy`               | `BOOL`                                             |                                                           | Communication indicator (TRUE = communication)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Input Const | `eSpFanMode`          | SYSTEMAIR\_SAVE\_CONTROL\_SP\_FAN\_MODE            | SYSTEMAIR\_SAVE\_CONTROL\_SP\_FAN\_MODE.PERCENT           | <p>Operating mode for the fan setpoints<br><br>By selecting this operating mode, the array is defined that is monitored for changes in the setpoints.<br>Example: eSpFanMode = SYSTEMAIR\_SAVE\_CONTROL\_SP\_FAN\_MODE.PERCENT<br>The array <code>arwSpFan\_Percent</code> is monitored for changes and transmitted if necessary.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Input Const | `eExhaustAirFanLevel` | SYSTEMAIR\_SAVE\_CONTROL\_EXHAUST\_AIR\_FAN\_LEVEL | SYSTEMAIR\_SAVE\_CONTROL\_EXHAUST\_AIR\_FAN\_LEVEL.NORMAL | Fan stage of the exhaust fan in manual mode                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| Input Const | `eSupplyAirFanLevel`  | SYSTEMAIR\_SAVE\_CONTROL\_SUPPLY\_AIR\_FAN\_LEVEL  | SYSTEMAIR\_SAVE\_CONTROL\_SUPPLY\_AIR\_FAN\_LEVEL.NORMAL  | Fan stage of the supply fan in manual mode                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Input Const | `diAdrOffset`         | `DINT`                                             | 0                                                         | <p>Offset for calculating the Modbus addresses (from the Modbus<br>registers) (permitted range: -1, 0, +1)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Input Const | `tTimeUpdateSetp`     | `TIME`                                             | TIME#45s0ms                                               | <p>Update interval for the processes influenced by the input<br><code>xUpdateSetp</code> influenced</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Input Const | `tTimeUpdateActual`   | `TIME`                                             | TIME#10s0ms                                               | <p>Update interval for the processes influenced by the input<br><code>xUpdateActual</code> influenced</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://support.powerio.com/hub/codesys-hvac/en/hvac-modbus-library/functionblocks/systemair/systemair_save_control.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
