> 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/belimo/belimo_p_22rtx_1u00x_2_full.md).

# BELIMO\_P\_22RTX\_1U00X\_2\_FULL

## `BELIMO_P_22RTX_1U00X_2_FULL` (FB)

`FUNCTION_BLOCK` BELIMO\_P\_22RTX\_1U00X\_2\_FULL

### Representation

<figure><img src="https://2592874069-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FQR4vCFzt6ixgsqlR3pdR%2Fuploads%2F1c5haerVZVoG1FfT0zzA%2FBELIMO_P_22RTX_1U00X_2_FULL.png?alt=media&amp;token=bd791dbe-465b-4ad2-89c3-e9caadee1b25" alt=""><figcaption></figcaption></figure>

### Short description

> Control of the Belimo device series P-22RT..-1U00..-2
>
> Typical application: room operating device in a zone

#### Guidelines - Software creation

Supported Modbus - Function Codes: 2, 3, 4, 6 and 16. Use the address information for addressing, not the register addresses. Registers from 111 onward are persistent in the device and must not be written cyclically!!! Unused registers contain the value 65535 (unsigned)(FFFF - hex) or -1 (signed). Unused registers within the defined ranges may be read / written.

In the configuration `eEcoBoostOnOffIconMode` = BELIMO\_P\_22RTX\_1U00X\_2\_FULL\_ICON\_MODE.OPERATION\_MODE is switched in ECO mode with the first rising edge at input `xBoostIcon` to On/Comfort mode. With the second rising edge, BOOST mode is then activated. When operated on the room operating device, switching from ECO to BOOST takes place immediately.&#x20;

{% hint style="info" %}
Remedy: write address 30 with FC06 !!! with the desired value, do not write address 22 at the same time.
{% endhint %}

Measured values - adjustment: Class 4

### Interfaces

#### Inputs

| Name                  | Data type                                       | Value range | Initial value                                                     | Function                                                                                                                                 |
| --------------------- | ----------------------------------------------- | ----------- | ----------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| *xEn*                 | `BOOL`                                          |             | TRUE                                                              | Enable / blocking of communication (TRUE = enable)                                                                                       |
| *byUnitId*            | `BYTE`                                          |             | 0                                                                 | Device address (0 .. 255)                                                                                                                |
| *xUpdateActual*       | `BOOL`                                          |             | FALSE                                                             | Update of actual values (at each rising edge)                                                                                            |
| *xUpdateSetp*         | `BOOL`                                          |             | FALSE                                                             | Update of setpoints (at each rising edge)                                                                                                |
| *xUpdateConfig*       | `BOOL`                                          |             | FALSE                                                             | Update of the configuration (at each rising edge) (read access)                                                                          |
| *xUpdateStates*       | `BOOL`                                          |             | FALSE                                                             | Update of the states (at each rising edge)                                                                                               |
| *xUpdateInfo*         | `BOOL`                                          |             | FALSE                                                             | Update of the information (at each rising edge)                                                                                          |
| *rSetpTempAbsNight*   | `REAL`                                          |             | 18.0                                                              | Absolute room setpoint temperature in night mode (unit depends on register address 122)                                                  |
| *rSetpTempAbsBaseDay* | `REAL`                                          |             | 22.0                                                              | Absolute base room setpoint temperature in day mode (unit depends on register address 120)                                               |
| *rSetpTempRelNight*   | `REAL`                                          |             | 0.0                                                               | Relative room setpoint temperature in night mode (unit depends on register address 122)                                                  |
| *rSetpTempRelBaseDay* | `REAL`                                          |             | 0.0                                                               | Relative base room setpoint temperature in day mode (unit depends on register address 122)                                               |
| *xMode*               | `BOOL`                                          |             | FALSE                                                             | Input for the operating mode/the On/Off icon (function depending on register addresses 139 - 141)                                        |
| *xEcoIcon*            | `BOOL`                                          |             | FALSE                                                             | Input for the Eco operating mode/icon (function depending on register addresses 139 - 141)                                               |
| *xBoostIcon*          | `BOOL`                                          |             | FALSE                                                             | Input for the Boost operating mode/icon (function depending on register addresses 139 - 141)                                             |
| *eSetpFanLevel*       | BELIMO\_P\_22RTX\_1U00X\_2\_FAN\_LEVEL          |             | BELIMO\_P\_22RTX\_1U00X\_2\_FAN\_LEVEL.STAGE\_0                   | Target fan stage                                                                                                                         |
| xDsplTemp             | BOOL                                            |             | TRUE                                                              | Display of the room temperature ( TRUE = display )                                                                                       |
| xDsplRelHumidity      | BOOL                                            |             | TRUE                                                              | Display of the relative room humidity ( TRUE = display )                                                                                 |
| xDsplCO2              | BOOL                                            |             | TRUE                                                              | Display of the CO2 concentration ( TRUE = display )                                                                                      |
| xDsplFanStages        | BOOL                                            |             | FALSE                                                             | Display of the operating elements for the fan ( TRUE = display )                                                                         |
| eTempDsplMode         | BELIMO\_P\_22RTX\_1U00X\_2\_MODE\_DISPLAY\_TEMP |             | BELIMO\_P\_22RTX\_1U00X\_2\_MODE\_DISPLAY\_TEMP.SETP\_TEMPERATURE | Definition of the function of the central temperature display area                                                                       |
| *eIconsHeatCool*      | BELIMO\_P\_22RTX\_1U00X\_2\_MODE\_HEAT\_COOL    |             | BELIMO\_P\_22RTX\_1U00X\_2\_MODE\_HEAT\_COOL.NONE                 | Selection of the icon display for heating or cooling mode                                                                                |
| *xDsplIconWarn*       | `BOOL`                                          |             | FALSE                                                             | Input for the display of the warning icon (TRUE = enable)                                                                                |
| *xDsplIconWind*       | `BOOL`                                          |             | FALSE                                                             | Input for the display of the window icon (TRUE = enable)                                                                                 |
| *xEnLocalAdj*         | `BOOL`                                          |             | FALSE                                                             | Input for the display of the operating elements on the room operating device (TRUE = display)                                            |
| xVisuPresence         | BOOL                                            |             | FALSE                                                             | Actuation of the presence button in the visualization (eEcoBoostOnOffIconMode = BELIMO\_P\_22RTX\_1U00X\_2\_ICON\_MODE.PRESENCE\_BUTTON) |
| *xResError*           | `BOOL`                                          |             | FALSE                                                             | Input for the reset of the output `eErrorCodeCom` (at each rising edge)                                                                  |

#### Outputs

| Name                    | Data type                                    | Value range | Initial value | Function                                                                                                                                                                                         |
| ----------------------- | -------------------------------------------- | ----------- | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| *eOperationMode*        | BELIMO\_P\_22RTX\_1U00X\_2\_OPERATION\_MODE  |             |               | Display of the current operating mode on the room operating device (register address 30)                                                                                                         |
| *xModeDev*              | `BOOL`                                       |             |               | Operating mode of the zone controller on the room operating device (FALSE = night mode, TRUE = day mode)                                                                                         |
| *xButtonPresence*       | `BOOL`                                       |             |               | Actuation of the presence button (pulse with duration `tTimeButtonPulse`) (RBG and/or VISU)                                                                                                      |
| *rSetpTempAbs*          | `REAL`                                       |             |               | Current absolute setpoint temperature depending on the parameter `eTemperatureUnit` (e.g. +23.5 degrees Celsius) (register address 34) (unit depends on register address 120)                    |
| *rOffset*               | `REAL`                                       |             |               | Current difference between `rSetpTempAbs` and `rAdjCenterSetpTemp` (range: +/- `rAdjOffsetSetpTemp`) in day mode (unit depends on register address 120)                                          |
| *rSetpTempRel*          | `REAL`                                       |             |               | Current relative setpoint temperature depending on the parameter `eOffsetUnit` (e.g. -2.0 Kelvin) (range: +/- `rAdjOffsetSetpTemp`) (register address 36) (unit depends on register address 122) |
| *rTemp*                 | `REAL`                                       |             |               | Room temperature (unit depends on register address 120)                                                                                                                                          |
| *rRelHumidity*          | `REAL`                                       |             |               | Relative room humidity in percent                                                                                                                                                                |
| *rCO2*                  | `REAL`                                       |             |               | CO2 concentration (ppm)                                                                                                                                                                          |
| *eCO2Status*            | BELIMO\_P\_22RTX\_1U00X\_2\_CO2\_STATUS      |             |               | Current status of CO2 actual value monitoring                                                                                                                                                    |
| *xSensorOffsetInDevice* | `BOOL`                                       |             |               | Display whether the sensor adjustment must be carried out in the device (TRUE = adjustment required in device, FALSE = adjustment required in FB)                                                |
| *rDewPointTemp*         | `REAL`                                       |             |               | Dew point temperature (unit depends on register address 120 in degrees Celsius or Fahrenheit)                                                                                                    |
| *eFanLevel*             | BELIMO\_P\_22RTX\_1U00X\_2\_FAN\_LEVEL       |             |               | Current fan stage depending on the parameter `eFanLevelConfig` (register address 22)                                                                                                             |
| *xDI1*                  | `BOOL`                                       |             |               | State of digital input 1 depending on the parameter `eDI1OutpMode` (RAW: FALSE = Open, TRUE = Closed with +24VDC, PULSE: pulse with duration `tTimeDIPulse` at each rising edge at input DI1)    |
| *xEnLocalAdjFb*         | `BOOL`                                       |             |               | Display whether local operation is possible (TRUE = local operation possible) — feedback                                                                                                         |
| *eBusTermin*            | BELIMO\_P\_22RTX\_1U00X\_2\_BUS\_TERMINATION |             |               | State of the Modbus terminating resistor (Active = Enabled)                                                                                                                                      |
| *sSerialNum*            | `STRING`                                     |             |               | Serial number of the device                                                                                                                                                                      |
| *wFirmwareVer*          | `WORD`                                       |             |               | Firmware version of the device                                                                                                                                                                   |
| *xAlarmCom*             | `BOOL`                                       |             |               | Collective fault - communication (TRUE = fault)                                                                                                                                                  |
| *eErrorCodeCom*         | ModbusErrorCode                              |             |               | Error code - communication (0 = no error)                                                                                                                                                        |
| *eErrorCodeDev*         | SPLUSS\_ERROR\_CODE\_TYPE\_2                 |             |               | Error code - device (0 = no error)                                                                                                                                                               |
| *xBusy*                 | `BOOL`                                       |             |               | Communication display (TRUE = communication)                                                                                                                                                     |

#### Inputs and outputs

| Name           | Data type        | Value range | Initial value | Function             |
| -------------- | ---------------- | ----------- | ------------- | -------------------- |
| *ModbusClient* | ModbusClientBase |             |               | Client of the device |

#### General information on setpoints / parameters (addresses 110 - 149)

The following setpoints / parameters (addresses 110 - 149) are valid for function block with the index `_FULL` valid.

#### Setpoints / parameters FULL

| Name                     | Data type                                              | Value range | Initial value                                                                     | Address | Function                                                                                                                                                                            |
| ------------------------ | ------------------------------------------------------ | ----------- | --------------------------------------------------------------------------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **tTimeUpdateActual**    | `TIME`                                                 |             | T#3s                                                                              |         | Update interval for the processes influenced by the input `xUpdateActual` (0 = no automatic update, > 0 cyclic update)                                                              |
| **tTimeUpdateSetp**      | `TIME`                                                 |             | T#45s                                                                             |         | Update interval for the processes influenced by the input `xUpdateSetp` (0 = no automatic update, > 0 cyclic update)                                                                |
| **tTimeUpdateStates**    | `TIME`                                                 |             | T#500ms                                                                           |         | Update interval for the processes influenced by the input `xUpdateStates` (0 = no automatic update, > 0 cyclic update)                                                              |
| **tTimeUpdateInfo**      | `TIME`                                                 |             | T#0s                                                                              |         | Update interval for the processes influenced by the input `xUpdateInfo` (0 = no automatic update, > 0 cyclic update)                                                                |
| **eDI1OutpMode**         | BELIMO\_P\_22RTX\_1U00X\_2\_DIGITAL\_INPUT\_OUTP\_MODE |             | BELIMO\_P\_22RTX\_1U00X\_2\_DIGITAL\_INPUT\_OUTP\_MODE.RAW                        |         | Operating mode of the output `xDI1` (RAW, PULSE)                                                                                                                                    |
| **tTimeDIPulse**         | `TIME`                                                 |             | T#1s                                                                              |         | Duration of the pulse at the output `xDI1`, if a rising edge is detected at the digital input (`eDI1OutpMode` = BELIMO\_P\_22RTX\_1U00X\_2\_FULL\_DIGITAL\_INPUT\_OUTP\_MODE.PULSE) |
| **eFanStageControlMode** | BELIMO\_P\_22RTX\_1U00X\_2\_FAN\_STAGES\_CONTROL\_MODE |             | BELIMO\_P\_22RTX\_1U00X\_2\_FAN\_STAGES\_CONTROL\_MODE.AUTOMATIC\_STAGES\_CONTROL | 31      | Definition of the operating mode for control of the fan stages                                                                                                                      |
| **tTimeButtonPulse**     | `TIME`                                                 |             | T#1s                                                                              |         | Duration of the pulse at output ‘xButton Presence’                                                                                                                                  |

#### Additional setpoints / parameters FULL

| Name                              | Data type                                              | Value range                                   | Initial value                                                             | Address   | Function                                                                                                                                                                                                                                                                                  |
| --------------------------------- | ------------------------------------------------------ | --------------------------------------------- | ------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| *rTempOffset*                     | `REAL`                                                 | +/- 15.0 K                                    | 0.0                                                                       | 110       | Room temperature offset (for calibration of the temperature sensor) in K                                                                                                                                                                                                                  |
| *rHumidityOffset*                 | `REAL`                                                 | +/- 20.0 %                                    | 0.0                                                                       | 111       | Offset of the room humidity (for calibration of the humidity sensor) in percent                                                                                                                                                                                                           |
| *rCO2Offset*                      | `REAL`                                                 | +/- 500 ppm                                   | 0.0                                                                       | 112       | Offset of the CO2 sensor (for calibration of the CO2 sensor) in ppm                                                                                                                                                                                                                       |
| *rCO2\_LED\_ThresholdGreenYellow* | `REAL`                                                 | 600.0 - 1249.0 ppm, only whole-number values  | 1000.0                                                                    | 115       | Threshold for switching the LED color from green to yellow                                                                                                                                                                                                                                |
| *rCO2\_LED\_ThresholdYellowRed*   | `REAL`                                                 | 1250.0 - 2000.0 ppm, only whole-number values | 1500.0                                                                    | 116       | Threshold for switching the LED color from yellow to red                                                                                                                                                                                                                                  |
| *xCO2\_LED\_Enable*               | `BOOL`                                                 |                                               | TRUE                                                                      | 117       | Enable / blocking of the CO2 LED (TRUE = enable)                                                                                                                                                                                                                                          |
| *eTemperatureUnit*                | BELIMO\_P\_22RTX\_1U00X\_2\_UNIT\_TEMPERATURE          |                                               | BELIMO\_P\_22RTX\_1U00X\_2\_UNIT\_TEMPERATURE.DEGREES\_CELSIUS            | 120       | Definition of the unit for temperature (influence: `rTemp` (address 1), `rDewPointTemp` (address 5) and `rSetpTemp` (address 34))                                                                                                                                                         |
| *eTemperatureUnitDisplay*         | BELIMO\_P\_22RTX\_1U00X\_2\_UNIT\_TEMPERATURE\_DISPLAY |                                               | BELIMO\_P\_22RTX\_1U00X\_2\_UNIT\_TEMPERATURE\_DISPLAY.DEGREES\_CELSIUS   | 121       | Definition of the unit for temperature display on the display (influence: display)                                                                                                                                                                                                        |
| *eOffsetUnit*                     | BELIMO\_P\_22RTX\_1U00X\_2\_UNIT\_TEMPERATURE          |                                               | BELIMO\_P\_22RTX\_1U00X\_2\_UNIT\_TEMPERATURE.DEGREES\_CELSIUS            | 122       | Definition of the unit for the relative setpoint temperature (influence: `rSetpTempRel` (address 36))                                                                                                                                                                                     |
| *eColorScheme*                    | BELIMO\_P\_22RTX\_1U00X\_2\_COLOR\_SCHEME              |                                               | BELIMO\_P\_22RTX\_1U00X\_2\_COLOR\_SCHEME.WHITE\_BACKGROUND               | 130       | Definition of the color scheme of the display                                                                                                                                                                                                                                             |
| *eDsplIconsHeatCool*              | BELIMO\_P\_22RTX\_1U00X\_2\_SYMBOL\_VISIBILITY         |                                               | BELIMO\_P\_22RTX\_1U00X\_2\_SYMBOL\_VISIBILITY.INVISIBLE                  | 134       | Display of the visibility of the icons for heating and cooling mode                                                                                                                                                                                                                       |
| *eWarningIconFunct*               | BELIMO\_P\_22RTX\_1U00X\_2\_WARNING\_ICON\_FUNCTION    |                                               | BELIMO\_P\_22RTX\_1U00X\_2\_WARNING\_ICON\_FUNCTION.DEVICE\_ERROR\_STATUS | 135       | Definition of the function of the icon `Warning`                                                                                                                                                                                                                                          |
| *eWindowIconFunct*                | BELIMO\_P\_22RTX\_1U00X\_2\_WINDOW\_ICON\_FUNCTION     |                                               | BELIMO\_P\_22RTX\_1U00X\_2\_WINDOW\_ICON\_FUNCTION.INPUT\_xDsplIconWind   | 136       | Definition of the function of the icon `Window`                                                                                                                                                                                                                                           |
| *eEcoBoostOnOffIconMode*          | BELIMO\_P\_22RTX\_1U00X\_2\_ICON\_MODE                 |                                               | BELIMO\_P\_22RTX\_1U00X\_2\_ICON\_MODE.PRESENCE\_BUTTON                   | 139 - 141 | Central definition of the functions of the icons `Eco`, `Boost` and `OnOff`                                                                                                                                                                                                               |
| *tBoostModeDuration*              | `TIME`                                                 |                                               | T#900s                                                                    | 142       | Duration of the operating mode `Boost`                                                                                                                                                                                                                                                    |
| *eSetpTempMode*                   | BELIMO\_P\_22RTX\_1U00X\_2\_SETP\_TEMP\_MODE           |                                               | BELIMO\_P\_22RTX\_1U00X\_2\_SETP\_TEMP\_MODE.ABSOLUTE\_SETPOINT           | 145       | Definition of the operating mode of the setpoint display (absolute / relative)                                                                                                                                                                                                            |
| *rAdjOffsetSetpTempAbs*           | `REAL`                                                 | -5.0 … +5.0 Kelvin                            | 3.0                                                                       | 147       | Definition of the adjustment range around the absolute base setpoint temperature (center value) (+/- 5.0 K) (automatic, internal conversion to other temperature units in the room operating device). Affects the adjustment ranges of the absolute and the relative setpoint temperature |
| *eFanLevelConfig*                 | BELIMO\_P\_22RTX\_1U00X\_2\_FAN\_LEVEL\_CONFIG         |                                               | BELIMO\_P\_22RTX\_1U00X\_2\_FAN\_LEVEL\_CONFIG.SEVEN\_STAGES              | 148       | Definition of the number of fan stages                                                                                                                                                                                                                                                    |
| *eFanControlMode*                 | BELIMO\_P\_22RTX\_1U00X\_2\_FAN\_CONTROL\_MODE         |                                               | BELIMO\_P\_22RTX\_1U00X\_2\_FAN\_CONTROL\_MODE.MANUAL\_MODE\_ONLY         | 1498      | Definition of the operating mode for fan control                                                                                                                                                                                                                                          |

### Description of functions

#### General

This function block controls room operating devices of the device series P-22RT..-1U00..-2 from Belimo via Modbus communication. The configuration (addresses 110 - 149) is carried out in the function block with the index `_FULL` internally.

#### Operating modes - room operating device (address 30) — outputs `eOperationMode` and `xModeDev`

Four operating modes are distinguished:

0: Off/Protection (`xModeDev` = FALSE) 1: On/Comfort (`xModeDev` = TRUE) 2: Eco Mode (`xModeDev` = TRUE) 3: Boost Mode (`xModeDev` = TRUE)

The operating modes 2 and 3 can only be selected in addition to operating mode 1. Operating mode 3 is active for a limited time and requires the highest fan stage to be enabled for correct operation. The operating modes are automatically determined depending on the operating mode (see below).

#### Central definition of the functions of the icons / operating elements `OnOff`, `Eco` and `Boost` (operating modes)

A total of four operating modes are distinguished, which are defined via addresses 139 - 141: (FULL: parameter `eEcoBoostOnOffIconMode`)

#### Operating mode INVISIBLE

| Visibility | Operability | Function                      |
| ---------- | ----------- | ----------------------------- |
| Eco: NO    | Eco: NO     | Icons not visible or operable |
| Boost: NO  | Boost: NO   | Icons not visible or operable |
| OnOff: NO  | OnOff: NO   | Icons not visible or operable |

#### Operating mode DISPLAY\_MODE

| Visibility | Operability | Function                           |
| ---------- | ----------- | ---------------------------------- |
| Eco: YES   | Eco: NO     | Display of the Eco and OnOff modes |
| Boost: NO  | Boost: NO   | Display of the Eco and OnOff modes |
| OnOff: YES | OnOff: NO   | Display of the Eco and OnOff modes |

#### Operating mode OPERATION\_MODE

| Visibility | Operability | Function                                                                                           |
| ---------- | ----------- | -------------------------------------------------------------------------------------------------- |
| Eco: YES   | Eco: YES    | Switching the functions at the room operating device as well as by rising edges at the icon inputs |
| Boost: YES | Boost: YES  | Switching the functions at the room operating device as well as by rising edges at the icon inputs |
| OnOff: YES | OnOff: YES  | Switching the functions at the room operating device as well as by rising edges at the icon inputs |

#### Operating mode PRESENCE\_BUTTON

| Visibility | Operability | Function                                                    |
| ---------- | ----------- | ----------------------------------------------------------- |
| Eco: NO    | Eco: NO     | Extension of occupancy time with external HVAC.Button1 - FB |
| Boost: NO  | Boost: NO   | Extension of occupancy time with external HVAC.Button1 - FB |
| OnOff: YES | OnOff: YES  | Extension of occupancy time with external HVAC.Button1 - FB |

In DISPLAY mode, the operating modes Eco Mode and On/Comfort are defined by the inputs `xEcoIcon` and `xMode` (TRUE = On). If none of the inputs is active, the operating mode Off/Protection is automatically selected.

In OPERATION mode, the operating modes ECO, Boost and OnOff are defined by the associated inputs (rising edges) and by operation at the room operating device.

In PRESENCE-BUTTON mode, the operating modes Off/Protection and On/Comfort are defined by input `xMode` (rising edge: On / Comfort, falling edge: Off/Protection) and in parallel by operation at the room operating device. Each time the room operating device triggers a change from night to day mode and vice versa, a pulse with duration `xButtonPresence` is generated at output `tTimeButtonPulse` Additionally, with each rising edge at input `xVisuPresence` a pulse is generated at output `xButtonPresence` is generated at output `tTimeButtonPulse` .

#### Restrictions in PRESENCE-BUTTON mode

1. In function block `HVAC.Button1` the parameters may `xEnClockButton` and `xEnToggle` must not be assigned the value FALSE.
2. In function block `HVAC.Button1` the parameters may `xEnClockButton` and `xEnToggle` must not be changed ONLINE.

#### Use of PRESENCE-BUTTON mode

<figure><img src="https://2592874069-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FQR4vCFzt6ixgsqlR3pdR%2Fuploads%2F4esVEtSjl76T3zdtg5k0%2FBELIMO_P_22RTX_1U00X_2_FULL_ANWENDUNG.png?alt=media&amp;token=c14f9582-2646-4c3c-a203-1e0521366d18" alt=""><figcaption></figcaption></figure>

#### Day mode / Night mode (Output `xModeDev`)

At the output `xModeDev` the current day-mode status is displayed on the room operating unit (TRUE = day mode).

#### Room set temperatures

The room set temperatures are determined depending on the parameter `eSetpTempMode` (address 145) in different ways:

1. Absolute setpoint (e.g. +23.5 degrees Celsius) (Index `Abs`) (Inputs `rSetpTempAbsNight`, `rSetpTempAbsBaseDay`) (Output `rSetpTempAbs`)
2. Relative setpoint (e.g. +1.0 Kelvin) (Index `Rel`) (Inputs `rSetpTempRelNight`, `rSetpTempRelBaseDay`) (Output `rSetpTempRel`)

Changes to the associated inputs are transferred immediately in the corresponding state, otherwise at the next transition to this state. Example: A change at input `rSetpTempAbsNight` is transferred immediately and takes effect in night mode. Example: A change at input `rSetpTempBaseDay` is not effective immediately in night mode, but only at the next transition to day mode.

Changes to parameter `rAdjOffsetSetpTempAbs` (address 147) are transferred immediately in the appropriate state, otherwise delayed. (FULL). Changes to the content of address 147 affect the absolute and relative set temperature.

The current values at the inputs `rSetpTempAbsNight` and `rSetpTempAbsBaseDay` are, depending on parameter `eTemperatureUnit` (address 120), to be specified. At the output Output `rSetpTempAbs` the current setpoint is then available in the selected unit. The current values at the inputs `rSetpTempRelNight` and `rSetpTempRelBaseDay` are, depending on parameter `eOffsetUnit` (address 122), to be specified. At the output Output `rSetpTempRel` the current setpoint is then available in the selected unit.

Night mode - room set temperature

When switching from day mode to night mode, the state at input `rSetpTempAbsNight` is transferred to the room operating unit and displayed there (`eSetpTempMode` = absolute set temperature). When switching from day mode to night mode, the state at input `rSetpTempRelNight` is transferred to the room operating unit and displayed there (`eSetpTempMode` = relative set temperature). Any change in the state at input `rSetpTempXXXNight` is transferred to the room operating unit during night mode.

Day mode - room set temperature

Case 1 - There is not yet a valid room set temperature in day mode

When switching from night mode to day mode, the state at input `rSetpTempAbsBaseDay` is transferred to the room operating unit and displayed there. On the room operating unit, adjustment is possible within the symmetrical range defined by address 147. The step size is fixed at 0.5K and changes only in the sequence X.0 - X.5 - X.0, etc.

Case 2 - A valid room set temperature is already present in day mode

When switching from night mode to day mode, the previous valid room set temperature is transferred to the room operating unit and displayed there. On the room operating unit, adjustment is possible within the symmetrical range defined by address 147. The step size is fixed at 0.5K and changes only in the sequence X.0 - X.5 - X.0, etc.

#### Output `xDI1`

At the output `xDI1` the state at input DI1 of the room operating unit is available in different ways (parameter `xDI1OutpMode`) is available.

Operating modes

RAW

The output immediately adopts the state at input DI1 (FALSE: contact open, TRUE: contact closed with +24VDC)

PULSE

Each rising edge at input DI1 triggers a pulse of duration at the corresponding output xDI1 `tTimeDIPulse` (default: 1s).

#### Setpoint / display of the fan stage

The preselection of the number of fan stages is made via the parameter `eFanLevelConfig` (address 148). In Boost Mode, the maximum fan stage is specified (independent of input `eSetpFanLevel`) . The fan stage is selected via input `eSetpFanLevel` within the permitted limits and transferred. The current fan stage is output via the output `eFanLevel` within the permitted limits. The display of the current fan stage and the setting options is additionally determined by the parameters `eFanStagesControlMode` (address 31) `eFanControlMode` (address 149), `eFanLevelConfig` (address 148) and `xDsplFanStages` (address 138).\
\
xDsplFanStages = FALSE:\
\
The fan symbol, the current fan stage and the buttons for selecting the fan stages are not displayed.\
\
xDsplFanStages = TRUE:

The fan symbol, the current fan stage and the buttons for selecting the fan stages are displayed. The number of fan stages is determined via the parameter 'eFanLevelConfig' (3 stages, 4 stages or 7 stages). The desired fan stages can be selected via input 'eSetpFanLevel' (stages 0-2, stages 0-3 or stages 0-6) as well as\
via the buttons on the room operating unit (= RBG). Feedback of the current fan stage on the RBG is via output 'eFanLevel' (stages 0-6).

Depending on the settings of the parameters 'eFanControlMode' and 'eFanStageControlMode', the following operating and display options result:\ <br>

<table data-header-hidden><thead><tr><th valign="top"></th><th valign="top"></th><th valign="top"></th><th valign="top"></th><th valign="top"></th></tr></thead><tbody><tr><td valign="top">eFanControlNode</td><td valign="top">eFanStageControlMode</td><td valign="top">Operation on the RBG</td><td valign="top">Input 'eSetpFanLevel'</td><td valign="top">Output 'eFanLevel'</td></tr><tr><td valign="top">MANUAL_MODE_ONLY</td><td valign="top">MANUAL_STAGES_CONTROL</td><td valign="top">Stages 0-6</td><td valign="top">Stages 0-6</td><td valign="top">Stages 0-6, last setpoint</td></tr><tr><td valign="top">MANUAL_MODE_ONLY</td><td valign="top">AUTOMATIC_STAGES_CONTROL</td><td valign="top">Stages 0-6</td><td valign="top">Stages 0-6</td><td valign="top">Stages 0-6, last setpoint</td></tr><tr><td valign="top">HYBRID_MODE</td><td valign="top">MANUAL_STAGES_CONTROL</td><td valign="top">A-0-6-A</td><td valign="top">Stages 0-6</td><td valign="top">Stages 0-6, last setpoint</td></tr><tr><td valign="top">HYBRID_MODE</td><td valign="top">AUTOMATIC_STAGES_CONTROL</td><td valign="top">A-0-6-A</td><td valign="top">Each write operation activates automatic mode</td><td valign="top">&#x3C;>A: stages 0-6 from the RBG<br>A: = input 'eSetpFanLevel'</td></tr></tbody></table>

Legend:

A ... automatic mode or the automatic symbol is displayed in addition to the fan symbol.

last setpoint ... The last setpoint defined for the fan stage (via input 'eSetpFanLevel' or operation on the RBG) determines the current fan stage.<br>

#### Evaluation of the current CO2 level using a multicolored LED

The current CO2 level is evaluated using a multicolored LED (off / green / yellow / red) and the output `eCO2Status` is performed. The threshold for the transition of the LED color from green to yellow is defined by the parameter `rCO2_LED_ThresholdwGreenYellow` (address 115). The threshold for the transition of the LED color from yellow to red is defined by the parameter `rCO2_LED_ThresholdYellowRed` (address 116). The evaluation and the LED display can be defined by the parameter `xCO2_LED_Enable` (address 117) (TRUE = display).

#### Display of symbols / actual values

The display of the desired symbols on the room operating unit display is triggered by the TRUE state of the associated inputs. These inputs are marked with the index `Dspl` labelled. Example: xDsplTemp = TRUE causes the current room temperature to be displayed on the display.

#### Display of faults

Faults are displayed at the collective output `xAlarm` (= TRUE). It includes communication faults (time delay: gc\_Parameters.gc\_tOnDelayxAlarmCom, default = 60s) and device faults (directly). The collective fault message, the collective warning message and the CO2 level that is too high (LED = red) are output here as a device fault. At the output `eErrorCodeCom` in the event of a communication error, an explanatory text for the cause is available. The cause of the last communication error is always displayed there.

### Codesys

InOut:

| Scope       | Name                            | Type                                                   | Initial                                                                           | Comment                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| ----------- | ------------------------------- | ------------------------------------------------------ | --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Input       | `xEn`                           | `BOOL`                                                 | TRUE                                                                              | Enable / blocking of communication (TRUE = enable)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| Input       | `byUnitId`                      | `BYTE`                                                 | 0                                                                                 | <p>Device address (1 .. 247) (via Belimo Assistant -<br>App via NFC)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| 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       | `xUpdateConfig`                 | `BOOL`                                                 | FALSE                                                                             | <p>Update of the configuration (on every rising<br>edge)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Input       | `xUpdateStates`                 | `BOOL`                                                 | FALSE                                                                             | <p>Update of the states (on every rising edge<br>)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Input       | `xUpdateInfo`                   | `BOOL`                                                 | FALSE                                                                             | <p>Update of the information (on every rising<br>edge)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Input       | `rSetpTempAbsNight`             | `REAL`                                                 | 18.0                                                                              | Absolute set temperature - night mode (unit depending on `eTemperatureUnit`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Input       | `rSetpTempAbsBaseDay`           | `REAL`                                                 | 22.0                                                                              | Absolute base set temperature - day mode (unit depending on `eTemperatureUnit`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Input       | `rSetpTempRelNight`             | `REAL`                                                 | 0.0                                                                               | Relative set temperature - night mode (unit depending on `eTemperatureUnit`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Input       | `rSetpTempRelBaseDay`           | `REAL`                                                 | 0.0                                                                               | Relative base set temperature - day mode (unit depending on `eTemperatureUnit`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Input       | `xMode`                         | `BOOL`                                                 | FALSE                                                                             | <p>Display of the icon <code>OnOff</code> (<code>eEcoBoostOnOffIconMode</code> =<br>BELIMO\_P\_22RTX\_1U00X\_2\_FULL\_ICON\_MODE.DISPLAY\_MODE)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Input       | `xEcoIcon`                      | `BOOL`                                                 | FALSE                                                                             | <p>Display of the icon <code>Eco</code> (<code>eEcoIconMode</code> =<br>BELIMO\_P\_22RTX\_1U00X\_2\_FULL\_ICON\_MODE.DISPLAY\_MODE)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| Input       | `xBoostIcon`                    | `BOOL`                                                 | FALSE                                                                             | <p>Operation of the icon <code>Boost</code> (<code>eBoostIconMode</code> =<br>BELIMO\_P\_22RTX\_1U00X\_2\_FULL\_ICON\_MODE.OPERATION\_MODE)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Input       | `eSetpFanLevel`                 | BELIMO\_P\_22RTX\_1U00X\_2\_FAN\_LEVEL                 | BELIMO\_P\_22RTX\_1U00X\_2\_FAN\_LEVEL.STAGE\_0                                   | <p>(each rising edge toggles Boost Mode)<br>Setpoint - Current fan stage depending on parameter <code>eFanLevelConfig</code><br><br>Depending on the parameters <code>eFanStagesControlMode</code> (Register 31 - setpoints\_0) and <code>eFanControlMode</code> The following operating options are available depending on the parameters (Register 31 - setpoints\_0) and (Register 149 - configuration\_0):<br>Register 31 = Automatic // Register 149 = Hybrid:<br>If stage 0 is selected on the RBG, the display of the current stage is deactivated and an automatic symbol is displayed.<br>If a stage greater than 0 is selected on the RBG, the display of the current stage is activated and the automatic symbol is hidden.<br>Stage selection is possible on the RBG and via Register 22.<br><br>In all other configurations:<br>The display of the current stage is active; it can be changed on the RBG and via Register 22, and the last change made remains in effect.</p> |
| Input       | `xDsplTemp`                     | `BOOL`                                                 | TRUE                                                                              | Display of room temperature (TRUE = display)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Input       | `xDsplRelHumidity`              | `BOOL`                                                 | TRUE                                                                              | Display of relative room humidity (TRUE = display)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| Input       | `xDsplCO2`                      | `BOOL`                                                 | TRUE                                                                              | Display of CO2 concentration (TRUE = display)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Input       | `xDsplFanStages`                | `BOOL`                                                 | FALSE                                                                             | <p>Display of the controls for the fan (TRUE =<br>display)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| Input       | `eTempDsplMode`                 | BELIMO\_P\_22RTX\_1U00X\_2\_MODE\_DISPLAY\_TEMP        | BELIMO\_P\_22RTX\_1U00X\_2\_MODE\_DISPLAY\_TEMP.SETP\_TEMPERATURE                 | <p>Definition of the function of the central temperature<br>display area</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Input       | `eIconsHeatCool`                | BELIMO\_P\_22RTX\_1U00X\_2\_MODE\_HEAT\_COOL           | BELIMO\_P\_22RTX\_1U00X\_2\_MODE\_HEAT\_COOL.NONE                                 | Selection of heating or cooling mode                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| Input       | `xDsplIconWarn`                 | `BOOL`                                                 | FALSE                                                                             | Display of the symbol `Warning` (TRUE = display)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Input       | `xDsplIconWind`                 | `BOOL`                                                 | FALSE                                                                             | Display of the symbol `Window` (TRUE = display)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Input       | `xEnLocalAdj`                   | `BOOL`                                                 | TRUE                                                                              | <p>Determines whether local operation is possible (TRUE =<br>enabled)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| Input       | `xVisuPresence`                 | `BOOL`                                                 | FALSE                                                                             | <p>Pressing the presence button in the visualization<br>(eEcoBoostOnOffIconMode =<br>BELIMO\_P\_22RTX\_1U00X\_2\_ICON\_MODE.PRESENCE\_BUTTON)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Input       | `xResError`                     | `BOOL`                                                 | FALSE                                                                             | <p>Reinitialization of the output <code>eErrorCodeCom</code> (on every<br>rising edge)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Inout       | `ModbusClient`                  | `ModbusClientBase`                                     |                                                                                   | Client of the device                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| Output      | `eOperationMode`                | BELIMO\_P\_22RTX\_1U00X\_2\_OPERATION\_MODE            |                                                                                   | <p>Current operating mode<br>0 = OFF\_PROTECTION: Night mode<br>1 = ON\_COMFORT: Day mode<br>2 = ECO\_MODE: Day mode — Eco mode<br>3 = BOOST\_MODE: Day mode — Boost mode</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Output      | `xModeDev`                      | `BOOL`                                                 |                                                                                   | <p>Operating mode of the device's zone control (FALSE =<br>night mode, TRUE = day mode)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Output      | `xButtonPresence`               | `BOOL`                                                 |                                                                                   | <p>Actuation of the presence button (pulse with duration<br><code>tTimeButtonPulse</code>) (RBG and/or VISU)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Output      | `rSetpTempAbs`                  | `REAL`                                                 |                                                                                   | <p>Current absolute set temperature depending on the<br>parameter <code>eTemperatureUnit</code> (e.g. +23.5 degrees Celsius) (<br>Register 34)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| Output      | `rOffset`                       | `REAL`                                                 |                                                                                   | <p>Current difference between <code>rSetpTempAbs</code> and<br><code>rAdjCenterSetpTemp</code> depending on the parameter<br><code>eTemperatureUnit</code> (range: +/- <code>rAdjOffsetSetpTemp</code>) in<br>day mode</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Output      | `rSetpTempRel`                  | `REAL`                                                 |                                                                                   | <p>Current relative set temperature depending on the<br>parameter <code>eOffsetUnit</code> (e.g. -2.0 Kelvin) (range: +/-<br><code>rAdjOffsetSetpTemp</code>) (Register 36)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Output      | `rTemp`                         | `REAL`                                                 |                                                                                   | <p>Current room temperature depending on the parameter<br><code>eUnitTemperature</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Output      | `rRelHumidity`                  | `REAL`                                                 |                                                                                   | Relative room humidity in percent                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Output      | `rCO2`                          | `REAL`                                                 |                                                                                   | Current CO2 level in ppm                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Output      | `eCO2Status`                    | BELIMO\_P\_22RTX\_1U00X\_2\_CO2\_STATUS                |                                                                                   | Current status of CO2 actual value monitoring                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Output      | `xSensorOffsetInDevice`         | `BOOL`                                                 |                                                                                   | <p>Indication of whether the sensors must be calibrated in the device<br>(TRUE = calibration required in the device, FALSE = calibration in the<br>FB required)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Output      | `rDewPointTemp`                 | `REAL`                                                 |                                                                                   | Dew point temperature in degrees Celsius or Fahrenheit                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Output      | `eFanLevel`                     | BELIMO\_P\_22RTX\_1U00X\_2\_FAN\_LEVEL                 |                                                                                   | <p>Current fan stage depending on the parameter<br><code>eFanLevelConfig</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Output      | `xDI1`                          | `BOOL`                                                 |                                                                                   | <p>State of digital input 1 depending on the<br>parameter <code>eDI1OutpMode</code>:</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Output      | `xEnLocalAdjFb`                 | `BOOL`                                                 |                                                                                   | <p>Indication whether local operation is possible (TRUE = local<br>operation possible) — feedback</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Output      | `eBusTermin`                    | BELIMO\_P\_22RTX\_1U00X\_2\_BUS\_TERMINATION           |                                                                                   | State of the Modbus terminating resistor (Active = Enabled)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Output      | `sSerialNum`                    | `STRING`                                               |                                                                                   | Serial number of the device                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Output      | `wFirmwareVer`                  | `WORD`                                                 |                                                                                   | Firmware version of the device                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 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 display (TRUE = communication)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Input Const | `xEcoIconPresenceButtonMode`    | `BOOL`                                                 | FALSE                                                                             | <p>Enable / block display / operation of the ECO-<br>icon / -button in the operating mode <code>PRESENCE\_BUTTON</code></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Input Const | `tTimeButtonPulse`              | `TIME`                                                 | TIME#1s0ms                                                                        | Duration of the pulse at output ‘xButton Presence’                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| Input Const | `eFanStageControlMode`          | BELIMO\_P\_22RTX\_1U00X\_2\_FAN\_STAGES\_CONTROL\_MODE | BELIMO\_P\_22RTX\_1U00X\_2\_FAN\_STAGES\_CONTROL\_MODE.AUTOMATIC\_STAGES\_CONTROL | <p>Definition of the operating mode for controlling the fan<br>stages</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| Input Const | `eFanControlMode`               | BELIMO\_P\_22RTX\_1U00X\_2\_FAN\_CONTROL\_MODE         | BELIMO\_P\_22RTX\_1U00X\_2\_FAN\_CONTROL\_MODE.MANUAL\_MODE\_ONLY                 | Definition of the operating mode for fan control                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Input Const | `eFanLevelConfig`               | BELIMO\_P\_22RTX\_1U00X\_2\_FAN\_LEVEL\_CONFIG         | BELIMO\_P\_22RTX\_1U00X\_2\_FAN\_LEVEL\_CONFIG.SEVEN\_STAGES                      | Definition of the number of fan stages                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Input Const | `rAdjOffsetSetpTempAbs`         | `REAL`                                                 | 3.0                                                                               | <p>Definition of the adjustment range around the absolute base<br>set temperature (center value) (+/- 5.0 K) (automatic,<br>internal conversion to other temperature units in the RBG)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Input Const | `eSetpTempMode`                 | BELIMO\_P\_22RTX\_1U00X\_2\_SETP\_TEMP\_MODE           | BELIMO\_P\_22RTX\_1U00X\_2\_SETP\_TEMP\_MODE.ABSOLUTE\_SETPOINT                   | <p>Affects the adjustment ranges of the absolute and relative set temperature<br>Definition of the operating mode of the setpoint display</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Input Const | `tBoostModeDuration`            | `TIME`                                                 | TIME#15m0s0ms                                                                     | Duration of the operating mode `Boost`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Input Const | `eEcoBoostOnOffIconMode`        | BELIMO\_P\_22RTX\_1U00X\_2\_ICON\_MODE                 | BELIMO\_P\_22RTX\_1U00X\_2\_ICON\_MODE.PRESENCE\_BUTTON                           | <p>Central definition of the functions of the icons <code>Eco</code>, <code>Boost</code> and <code>OnOff</code><br><br>INVISIBLE (icons not visible or operable)<br><br>> Visibility/operability on the RBG<br><br>Eco: no no<br>Boost: no no<br>OnOff: no no<br><br>DISPLAY\_MODE (display of the Eco and OnOff modes)<br><br>> Visibility/operability on the RBG<br><br>Eco: yes no<br>Boost: no no<br>OnOff: yes no<br><br>OPERATION\_MODE (switching the functions on the RBG as well as via rising edges at the icon inputs)<br><br>> Visibility/operability on the RBG<br><br>Eco: yes yes<br>Boost: yes yes<br>OnOff: yes yes<br><br>PRESENCE\_BUTTON (extension of occupancy time with external HVAC.Button1 - FB)<br><br>> Visibility/operability on the RBG<br><br>Eco: no no<br>Boost: no no<br>OnOff: yes yes</p>                                                                                                                                                              |
| Input Const | `eWindowIconFunct`              | BELIMO\_P\_22RTX\_1U00X\_2\_WINDOW\_ICON\_FUNCTION     | BELIMO\_P\_22RTX\_1U00X\_2\_WINDOW\_ICON\_FUNCTION.INPUT\_xDsplIconWind           | Definition of the function of the icon `Window`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Input Const | `eWarningIconFunct`             | BELIMO\_P\_22RTX\_1U00X\_2\_WARNING\_ICON\_FUNCTION    | BELIMO\_P\_22RTX\_1U00X\_2\_WARNING\_ICON\_FUNCTION.DEVICE\_ERROR\_STATUS         | Definition of the function of the icon `Warning`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Input Const | `eDsplIconsHeatCool`            | BELIMO\_P\_22RTX\_1U00X\_2\_SYMBOL\_VISIBILITY         | BELIMO\_P\_22RTX\_1U00X\_2\_SYMBOL\_VISIBILITY.INVISIBLE                          | <p>Display of the visibility of the icons for heating and<br>cooling mode</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Input Const | `eColorScheme`                  | BELIMO\_P\_22RTX\_1U00X\_2\_COLOR\_SCHEME              | BELIMO\_P\_22RTX\_1U00X\_2\_COLOR\_SCHEME.WHITE\_BACKGROUND                       | Definition of the color scheme of the display                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Input Const | `eOffsetUnit`                   | BELIMO\_P\_22RTX\_1U00X\_2\_UNIT\_TEMPERATURE          | BELIMO\_P\_22RTX\_1U00X\_2\_UNIT\_TEMPERATURE.DEGREES\_CELSIUS                    | <p>Definition of the unit for the offset temperature (<br>Influence: <code>rSetpTempRel</code> (Register 36))</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Input Const | `eTemperatureUnitDisplay`       | BELIMO\_P\_22RTX\_1U00X\_2\_UNIT\_TEMPERATURE\_DISPLAY | BELIMO\_P\_22RTX\_1U00X\_2\_UNIT\_TEMPERATURE\_DISPLAY.DEGREES\_CELSIUS           | <p>Definition of the unit for the temperature display on the display<br>(Influence: Display)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Input Const | `eTemperatureUnit`              | BELIMO\_P\_22RTX\_1U00X\_2\_UNIT\_TEMPERATURE          | BELIMO\_P\_22RTX\_1U00X\_2\_UNIT\_TEMPERATURE.DEGREES\_CELSIUS                    | <p>Definition of the unit for temperature (influence:<br><code>rTemp</code> (Register 1), <code>rDewPointTemp</code> (Register 5) and<br><code>rSetpTemp</code> (Register 34))</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| Input Const | `xCO2_LED_Enable`               | `BOOL`                                                 | TRUE                                                                              | Enable / blocking of the CO2 LED (TRUE = enable)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Input Const | `rCO2_LED_ThresholdYellowRed`   | `REAL`                                                 | 1500.0                                                                            | <p>Threshold for changing the LED color from yellow to red<br>(1250.0 - 2000.0 ppm, integer values only)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Input Const | `rCO2_LED_ThresholdGreenYellow` | `REAL`                                                 | 1000.0                                                                            | <p>Threshold for changing the LED color from green to<br>yellow (600.0 - 1249.0 ppm, integer values only)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Input Const | `rCO2Offset`                    | `REAL`                                                 | 0.0                                                                               | <p>Offset of the CO2 sensor (for calibrating the CO2 sensor)<br>in ppm (+/- 500 ppm)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Input Const | `rHumidityOffset`               | `REAL`                                                 | 0.0                                                                               | <p>Offset of the room humidity (for calibrating the humidity sensor<br>) in percent (+/- 20.0 %)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| Input Const | `rTempOffset`                   | `REAL`                                                 | 0.0                                                                               | <p>Offset of the room temperature (for calibrating the<br>temperature sensor) in K (+/- 15.0 K)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Input Const | `tTimeDIPulse`                  | `TIME`                                                 | TIME#1s0ms                                                                        | <p>Duration of the pulse at the output <code>xDI1</code>, if a rising edge is detected at the digital<br>input (<br><code>eDI1OutpMode</code> =<br>BELIMO\_P\_22RTX\_1U00X\_2\_FULL\_DIGITAL\_INPUT\_OUTP\_MODE.PULSE)</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Input Const | `eDI1OutpMode`                  | BELIMO\_P\_22RTX\_1U00X\_2\_DIGITAL\_INPUT\_OUTP\_MODE | BELIMO\_P\_22RTX\_1U00X\_2\_DIGITAL\_INPUT\_OUTP\_MODE.RAW                        | Operating mode of the output `xDI1` (RAW, PULSE)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Input Const | `tTimeUpdateInfo`               | `TIME`                                                 | TIME#0ms                                                                          | <p>Update interval for the processes influenced by the input<br><code>xUpdateInfo</code> be influenced</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Input Const | `tTimeUpdateStates`             | `TIME`                                                 | TIME#500ms                                                                        | <p>Update interval for the processes influenced by the input<br><code>xUpdateStates</code> be influenced</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Input Const | `tTimeUpdateSetp`               | `TIME`                                                 | TIME#45s0ms                                                                       | <p>Update interval for the processes influenced by the input<br><code>xUpdateSetp</code> be influenced</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Input Const | `tTimeUpdateActual`             | `TIME`                                                 | TIME#3s0ms                                                                        | <p>Update interval for the processes influenced by the input<br><code>xUpdateActual</code> be 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/belimo/belimo_p_22rtx_1u00x_2_full.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.
