# FireDamperMot\_OnOff

## `FireDamperMot_OnOff` (FB)

FUNCTION\_BLOCK FireDamperMot\_OnOff

### Short description

> Control of a motorized fire damper with two position feedbacks\
> Additional functions: Functional test of the fire damper\
> Typical application: Control of a fire damper in an HVAC system

### Representation

<figure><img src="https://2592874069-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FQR4vCFzt6ixgsqlR3pdR%2Fuploads%2Fgit-blob-1a20e1988265eb3fd74aca24731b96c40fa2f099%2FFireDamperMot_OnOff_FB.png?alt=media" alt=""><figcaption></figcaption></figure>

### Function description

#### General

This function block controls a binary motorized fire damper ( *xEn* = TRUE = opening ), monitors the run times during the opening and closing operations and can perform a complete fire damper test.\
The function block can be operated either in normal mode or in test mode ( = fire damper test ).\
The test mode has higher priority than normal mode and can be triggered by a rising edge at the input *xTestEx* and / or at the setpoint / parameter **xRunTest** is triggered.

#### Enable opening / closing of the fire damper before manual override *xAB*

The enable for opening / closing of the fire damper before manual override *xAB* is passed through unchanged from the request to open / close the fire damper *xEn* if the fire damper test is not active.

#### Enable opening / closing of the fire damper after manual override *xHB*

The enable for opening / closing of the fire damper after manual override *xHB* corresponds to the enable for opening / closing of the fire damper before manual override *xAB* additionally extended by a manual override module

| *xAB* | **eManModeB**  | *xHB* | Notes                                          |
| ----- | -------------- | ----- | ---------------------------------------------- |
| FALSE | eMANBIN.Auto   | FALSE | Manual override module in automatic            |
| TRUE  | eMANBIN.Auto   | TRUE  | Manual override module in automatic            |
| X     | eMANBIN.ManOn  | TRUE  | Manual override module in manual operation On  |
| X     | eMANBIN.ManOff | FALSE | Manual override module in manual operation Off |

Legend: X = don't care

#### Selection of operating mode *wMode*

The selection of the operating mode currently allows two valid variants:

> 1. ‘wMode’ = 1: The function block behaves like the function block ‘FireDamperMot’
>    1. xHB = TRUE: Immediate alarm message if FD according to feedback is not open ( fire case )
>    2. FD test: fixed sequence — closing + opening
> 2. ‘wMode’ = 2: The function block can be used for applications in Switzerland, where the fire dampers are opened/closed in parallel with the demand of the HVAC system.
>    1. xHB = FALSE: Immediate alarm message if FD according to feedback is not closed after expiration of the run time
>    2. xHB = TRUE: Immediate alarm message if FD according to feedback is not open after expiration of the run time ( fire case )
>    3. FD test: xClosed = TRUE: fixed sequence — opening + closing
>    4. FD test: xOpen = TRUE: fixed sequence — closing + opening

#### Aggregate fault *xAlarm*

‘wMode’ = 1:\
\
The collective alarm *xAlarm* is activated ( = TRUE ) if at least one of the following conditions is met:

\
1\) The fault message for the open feedback *xAlarmOpen* is active ( = TRUE ).\
\
2\) The fault message for the closed feedback \*xAlarmClosed\* is active ( = TRUE ).\
\
3\) The fire damper is not fully open ( \*xOpen\* = FALSE ).\
( Background: Any fire damper not fully open represents a faulty condition ).\
\
4\) The input \*xAlarmIn\* is active ( = TRUE ).\
\
In all other cases the collective alarm \*xAlarm\* is not activated ( = FALSE ).\
\
‘wMode’ = 2:\
\
The collective alarm \*xAlarm\* is activated ( = TRUE ) if at least one of the conditions described below is met:\
\
1\) The fault message for the open feedback \*xAlarmOpen\* is active ( = TRUE ).\
\
2\) The fault message for the closed feedback \*xAlarmClosed\* is active ( = TRUE ).\
\
3\) xHB = TRUE: The fire damper is not fully open ( \*xOpen\* = FALSE ).\
( Background: Any fire damper not fully open represents a faulty condition ).\
\
4\) xHB = FALSE: The fire damper is not fully closed ( \*xClosed\* = FALSE ).\
( Background: Any fire damper not fully closed represents a faulty condition ).\
\
5\) The input \*xAlarmIn\* is active ( = TRUE ).\
\
In all other cases the collective alarm \*xAlarm\* is not activated ( = FALSE ).

#### Enable / disable of the fault for the open feedback *xAlarmOpen*

Monitoring of the damper run time during the opening operation against an adjustable maximum value ( **tOpen** ) starts if, in normal operation, at least one of the following conditions is met:

1\) A rising edge ( FALSE > TRUE ) is detected at the output *xHB* ( = normal case ).\
\
2\) The request to open is active ( \*xEn\* = TRUE ) and at the same time a rising edge ( FALSE > TRUE ) is detected at the input \*xQuit\*.\
\
3\) The output \*xHB\* is active ( = TRUE ) and at the same time a falling edge ( TRUE > FALSE ) is detected at the input \*xOpen\*.\
\
The fault for the open feedback \*xAlarmOpen\* is activated ( = TRUE ) if, after the expiry of the maximum run time \*\*tOpen\*\* with the output active ( \*xHB\* = TRUE ), at least one of the following conditions is met:\
\
1\) The feedback for full open is not active ( \*xOpen\* = FALSE ) ( = normal case ).\
\
2\) The feedbacks \*xOpen\* and \*xClosed\* have the same state.\
\
The fault for the open feedback \*xAlarmOpen\* is deactivated ( = FALSE ) if a rising edge ( FALSE > TRUE ) is detected at the input \*xQuit\*.

#### Enable / disable of the fault for the closed feedback *xAlarmClosed*

Monitoring of the damper run time during the closing operation against an adjustable maximum value ( **tclose** ) starts if, in normal operation, at least one of the following conditions is met:

1\) A falling edge ( TRUE > FALSE ) is detected at the output *xHB* ( = normal case ).\
\
2\) The request to close is active ( \*xEn\* = FALSE ) and at the same time a rising edge ( FALSE > TRUE ) is detected at the input \*xQuit\*.\
\
The fault for the closed feedback \*xAlarmClosed\* is activated ( = TRUE ) if, after the expiry of the maximum run time \*\*tClose\*\* with the output not active ( \*xHB\* = FALSE ), at least one of the following conditions is met:\
\
1\) The feedback for full closed is not active ( \*xClosed\* = FALSE ) ( = normal case ).\
\
2\) The feedbacks \*xOpen\* and \*xClosed\* have the same state.\
\
The fault for the closed feedback \*xAlarmClosed\* is deactivated ( = FALSE ) if a rising edge ( FALSE > TRUE ) is detected at the input \*xQuit\*.

#### Enable / disable of the fault message for the released but not opened fire damper after expiration of the run time ( FALSE = disable, TRUE = enable ) *xAlarmOn\_Closed*

The enabling of the fault message occurs ( prerequisite: ‘wMode’ = 2 ) if, after expiration of any run time monitoring, the released fire damper ( ‘xHB’ = TRUE )\
is not fully open ( ‘xOpen’ = FALSE ) ( = fire case ).\
The fault message is deactivated ( = FALSE ) if at the input *xQuit* a rising edge ( FALSE > TRUE ) is detected.\
It is also deactivated ( = FALSE ) in all other modes ( ‘wMode’ <> 2 ).

#### Enable / disable of the fault message for the locked but not closed fire damper after expiration of the run time ( FALSE = disable, TRUE = enable ) *xAlarmOff\_Opened*

The enabling of the fault message occurs ( prerequisite: ‘wMode’ = 2 ) if, after expiration of any run time monitoring, the locked fire damper ( ‘xHB’ = FALSE )\
is not fully closed ( ‘xClosed’ = FALSE ).\
The fault message is deactivated ( = FALSE ) if at the input *xQuit* a rising edge ( FALSE > TRUE ) is detected.\
It is also deactivated ( = FALSE ) in all other modes ( ‘wMode’ <> 2 ).

#### Duration of the last full opening *tLastOpen*

The measurement of the duration begins whenever at least one of the following conditions is met:

1\) A rising edge ( FALSE > TRUE ) is detected at the input *xOpen* is detected.\
\
2\) A falling edge ( TRUE > FALSE ) is detected at the input \*xOpen\*.\
\
3\) A rising edge ( FALSE > TRUE ) is detected at the input \*xClosed\*.\
\
4\) A falling edge ( TRUE > FALSE ) is detected at the input \*xClosed\*. ( normal case )\
\
5\) A rising edge ( FALSE > TRUE ) is detected at the output \*xHB\*.\
\
6\) A falling edge ( TRUE > FALSE ) is detected at the output \*xHB\*.\
\
At this output, after each rising edge on the full open feedback \*xOpen\* ( FALSE > TRUE ), the run time is available.

#### Duration of the last full closing *tLastClosed*

The measurement of the duration begins whenever at least one of the following conditions is met:

1\) A rising edge ( FALSE > TRUE ) is detected at the input *xOpen* is detected.\
\
2\) A falling edge ( TRUE > FALSE ) is detected at the input \*xOpen\*. ( normal case )\
\
3\) A rising edge ( FALSE > TRUE ) is detected at the input \*xClosed\*.\
\
4\) A falling edge ( TRUE > FALSE ) is detected at the input \*xClosed\*.\
\
5\) A rising edge ( FALSE > TRUE ) is detected at the output \*xHB\*.\
\
6\) A falling edge ( TRUE > FALSE ) is detected at the output \*xHB\*.\
\
At this output, after each rising edge on the full closed feedback \*xClosed\* ( FALSE > TRUE ), the run time is available.

#### Duration of the current opening / closing in *tRunTime*

At this output the current run time is available during each run time measurement.

#### Testing the functions of the fire damper ( test mode )

The test mode is always generally triggered if at least one of the following conditions is met:

1\) A rising edge ( FALSE > TRUE ) is detected at the input *xTestEx* detected.\
\
2\) The active state ( = TRUE ) is detected at the setpoint / parameter \*xRunTest\*. The active state is immediately reset ( = FALSE ) after detection.\
\
However, the actual test mode only takes place if the feedback of manual/automatic operation \*eAOO\* ( 0 = automatic, >0 = manual ) contains the value 0 and at the same time the operating mode of the manual override for the digital output \*xHB\* signals automatic operation ( eMANBIN = eMANBIN.Auto ).\
\
‘wMode’ = 1:\
In test mode a closing and subsequent opening of the fire damper takes place, each with run time monitoring. At the beginning of the test mode the outputs \*xAlarmOpen\*, \*xAlarmClosed\*, \*tTestOpen\*, \*tTestClosed\* and \*xTestOK\* are reset ( = FALSE ).\
\
Now the control command for closing is triggered and the run time is monitored for exceeding the maximum value \*\*tClosed\*\*. If the correct feedback situation ( \*xClosed\* = TRUE and \*xOpen\* = FALSE ) is reached without exceeding the maximum value, the output \*xAlarmClosed\* is not activated ( = FALSE ). In all other situations the output \*xAlarmClosed\* is activated ( = TRUE ).\
\
Now the control command for opening is triggered and the run time is monitored for exceeding the maximum value \*\*tOpen\*\*. If the correct feedback situation ( \*xOpen\* = TRUE and \*xClosed\* = FALSE ) is reached without exceeding the maximum value, the output \*xAlarmOpen\* is not activated ( = FALSE ). In all other situations the output \*xAlarmOpen\* is activated ( = TRUE ).\
\
The result indicator for the fire damper test \*xTestOK\* is activated ( = test successful ) if neither of the two outputs \*xAlarmOpen\* or \*xAlarmClosed\* is active ( = TRUE ). The achieved values \*tLastOpen\* and \*tLastClosed\* are each assigned to the outputs \*tTestOpen\* and \*tTestClosed\* and stored until the next fire damper test.\
\
The test mode ends automatically as soon as the inspection of the fire damper is completed.\
\
‘wMode’ = 2:\
\
The sequence for the test mode is determined at the time of its initiation:\
\
a) ‘xClosed’ = TRUE: The sequence ‘opening - closing’ is executed\
b) ‘xOpen’ = TRUE: The sequence ‘closing - opening’ is executed\
\
Sequence Closing - Opening:\
\
In test mode a closing and subsequent opening of the fire damper takes place, each with run time monitoring. At the beginning of the test mode the outputs \*xAlarmOpen\*, \*xAlarmClosed\*, \*tTestOpen\*, \*tTestClosed\* and \*xTestOK\* are reset ( = FALSE ).\
\
Now the control command for closing is triggered and the run time is monitored for exceeding the maximum value \*\*tClosed\*\*. If the correct feedback situation ( \*xClosed\* = TRUE and \*xOpen\* = FALSE ) is reached without exceeding the maximum value, the output \*xAlarmClosed\* is not activated ( = FALSE ). In all other situations the output \*xAlarmClosed\* is activated ( = TRUE ).\
\
Now the control command for opening is triggered and the run time is monitored for exceeding the maximum value \*\*tOpen\*\*. If the correct feedback situation ( \*xOpen\* = TRUE and \*xClosed\* = FALSE ) is reached without exceeding the maximum value, the output \*xAlarmOpen\* is not activated ( = FALSE ). In all other situations the output \*xAlarmOpen\* is activated ( = TRUE ).\
\
The result indicator for the fire damper test \*xTestOK\* is activated ( = test successful ) if neither of the two outputs \*xAlarmOpen\* or \*xAlarmClosed\* is active ( = TRUE ). The achieved values \*tLastOpen\* and \*tLastClosed\* are each assigned to the outputs \*tTestOpen\* and \*tTestClosed\* and stored until the next fire damper test.\
\
The test mode ends automatically as soon as the inspection of the fire damper is completed.\
\
Sequence Opening - Closing:\
\
In test mode an opening and subsequent closing of the fire damper takes place, each with run time monitoring. At the beginning of the test mode the outputs \*xAlarmOpen\*, \*xAlarmClosed\*, \*tTestOpen\*, \*tTestClosed\* and \*xTestOK\* are reset ( = FALSE ).\
\
Now the control command for opening is triggered and the run time is monitored for exceeding the maximum value \*\*tOpen\*\*. If the correct feedback situation ( \*xOpen\* = TRUE and \*xClosed\* = FALSE ) is reached without exceeding the maximum value, the output \*xAlarmOpen\* is not activated ( = FALSE ). In all other situations the output \*xAlarmOpen\* is activated ( = TRUE ).\
\
Now the control command for closing is triggered and the run time is monitored for exceeding the maximum value \*\*tClosed\*\*. If the correct feedback situation ( \*xClosed\* = TRUE and \*xOpen\* = FALSE ) is reached without exceeding the maximum value, the output \*xAlarmClosed\* is not activated ( = FALSE ). In all other situations the output \*xAlarmClosed\* is activated ( = TRUE ).\
\
The result indicator for the fire damper test \*xTestOK\* is activated ( = test successful ) if neither of the two outputs \*xAlarmOpen\* or \*xAlarmClosed\* is active ( = TRUE ). The achieved values \*tLastOpen\* and \*tLastClosed\* are each assigned to the outputs \*tTestOpen\* and \*tTestClosed\* and stored until the next fire damper test.\
\
The test mode ends automatically as soon as the inspection of the fire damper is completed.

#### Prerequisites

> **Prerequisite for the use of the function block FireDamperMot\_OnOff**
>
> The use of the TimeRead2 function block is required for correct operation.

### CODESYS

InOut:

| Scope       | Name               | Type     | Initial      |
| ----------- | ------------------ | -------- | ------------ |
| Input       | `xEn`              | `BOOL`   |              |
| Input       | `xAlarmIn`         | `BOOL`   | FALSE        |
| Input       | `eAOO`             | eManBin  | eManBin.Auto |
| Input       | `xOpen`            | `BOOL`   |              |
| Input       | `xClosed`          | `BOOL`   |              |
| Input       | `xQuit`            | `BOOL`   | FALSE        |
| Input       | `xTestEx`          | `BOOL`   | FALSE        |
| Input       | `wMode`            | `WORD`   | 2            |
| Output      | `sLine1`           | `STRING` |              |
| Output      | `sLine2`           | `STRING` |              |
| Output      | `sText`            | `STRING` |              |
| Output      | `xHB`              | `BOOL`   |              |
| Output      | `xAB`              | `BOOL`   |              |
| Output      | `xAlarm`           | `BOOL`   |              |
| Output      | `xAlarmOpen`       | `BOOL`   |              |
| Output      | `xAlarmClosed`     | `BOOL`   |              |
| Output      | `xAlarmOn_Closed`  | `BOOL`   |              |
| Output      | `xAlarmOff_Opened` | `BOOL`   |              |
| Output      | `xTestOK`          | `BOOL`   |              |
| Output      | `tLastOpen`        | `TIME`   |              |
| Output      | `tLastClosed`      | `TIME`   |              |
| Output      | `tTestOpen`        | `TIME`   |              |
| Output      | `tTestClosed`      | `TIME`   |              |
| Output      | `tRunTime`         | `TIME`   |              |
| Output      | `xAuto`            | `BOOL`   |              |
| Input Const | `udiOpen`          | `UDINT`  | 150          |
| Input Const | `udiClose`         | `UDINT`  | 25           |
| Input Const | `eManModeB`        | eMANBIN  | eMANBIN.Auto |
| Input Const | `xRunTest`         | `BOOL`   | FALSE        |
| Input Const | `sEditLine2`       | `STRING` | ‘’           |
| Input Const | `sEditLine1`       | `STRING` | 'Room'       |
