1

(*

     2

 * (c) 2005 Mario de Sousa

     3

 *

     4

 * Offered to the public under the terms of the GNU General Public License

     5

 * as published by the Free Software Foundation; either version 2 of the

     6

 * License, or (at your option) any later version.

     7

 *

     8

 * This program is distributed in the hope that it will be useful, but

     9

 * WITHOUT ANY WARRANTY; without even the implied warranty of

    10

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General

    11

 * Public License for more details.

    12

 *

    13

 * This code is made available on the understanding that it will not be

    14

 * used in safety-critical situations without a full and competent review.

    15

 *)

    16

    17

(*

    18

 * An IEC 61131-3 IL and ST compiler.

    19

 *

    20

 * Based on the

    21

 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    22

 *

    23

 *)

    24

    25

(*

    26

 * This is part of the library conatining the functions

    27

 * and function blocks defined in the standard.

    28

 *

    29

 * Timer Function Blocks

    30

 * ---------------------

    31

 *

    32

 * NOTE: The timing diagrams in the comments were taken from the 

    33

 *       IEC 61131-3 standard.

    34

 *)

    35

    36

    37

    38

(****************************************************************

    39

    40

                  TP - pulse timing - state machine

    41

    42

    43

            +--------+     ++ ++   +--------+

    44

       IN   |        |     || ||   |        |

    45

          --+        +-----++-++---+        +---------

    46

            t0       t1    t2 t3    t4       t5

    47

            +----+         +----+  +----+

    48

       Q    |    |         |    |  |    |

    49

          --+    +---------+    +--+    +-------------

    50

            t0   t0+PT    t2 t2+PT t4  t4+PT

    51

         PT      +---+          +       +---+

    52

          :     /    |         /|      /    |

    53

       ET :    /     |        / |     /     |

    54

          :   /      |       /  |    /      |

    55

          :  /       |      /   |   /       |

    56

          0-+        +-----+    +--+        +---------

    57

            t0       t1    t2      t4       t5

    58

    59

    60

        2        +---+          +       +---+

    61

STATE   1   +----+   |     +----|  +----+   | 

    62

        0 --+        +-----+    +--+        +---------

    63

    64

    65

****************************************************************)

    66

    67

FUNCTION_BLOCK TP

    68

  VAR_INPUT

    69

    IN : BOOL;  (* first input parameter *)

    70

    PT : TIME;  (* second input parameter *)

    71

  END_VAR

    72

  VAR_OUTPUT

    73

    Q : BOOL := FALSE;  (* first output parameter *)

    74

    ET : TIME := T#0s;  (* second output parameter *)

    75

  END_VAR

    76

    77

  VAR

    78

    STATE : SINT := 0;  (* internal state: 0-reset, 1-counting, 2-set *)

    79

    PREV_IN : BOOL := FALSE;

    80

    CURRENT_TIME, START_TIME : TIME;

    81

  END_VAR

    82

    83

  {data__->CURRENT_TIME = __CURRENT_TIME;}

    84

    85

  IF ((STATE = 0) AND NOT(PREV_IN) AND IN)   (* found rising edge on IN *)

    86

  THEN

    87

    (* start timer... *)

    88

    STATE := 1;

    89

    Q := TRUE;

    90

    START_TIME := CURRENT_TIME;

    91

    92

  ELSIF (STATE = 1)

    93

  THEN

    94

    IF ((START_TIME + PT) <= CURRENT_TIME)

    95

    THEN

    96

      STATE := 2;

    97

      Q := FALSE;

    98

      ET := PT;

    99

    ELSE

   100

      ET := CURRENT_TIME - START_TIME;

   101

    END_IF;

   102

  END_IF;

   103

   104

  IF ((STATE = 2) AND NOT(IN))

   105

  THEN

   106

    ET := T#0s;

   107

    STATE := 0;

   108

  END_IF;

   109

   110

   111

  PREV_IN := IN;

   112

   113

END_FUNCTION_BLOCK

   114

   115

   116

   117

   118

(****************************************************************

   119

   120

             TON - On-delay timing - state machine

   121

   122

   123

            +--------+        +---+   +--------+

   124

       IN   |        |        |   |   |        |

   125

          --+        +--------+   +---+        +-------------

   126

            t0       t1       t2  t3  t4       t5

   127

                 +---+                     +---+

   128

       Q         |   |                     |   |

   129

          -------+   +---------------------+   +-------------

   130

              t0+PT  t1                t4+PT   t5

   131

         PT      +---+                     +---+

   132

          :     /    |            +       /    |

   133

       ET :    /     |           /|      /     |

   134

          :   /      |          / |     /      |

   135

          :  /       |         /  |    /       |

   136

          0-+        +--------+   +---+        +-------------

   137

            t0       t1       t2  t3  t4       t5

   138

   139

   140

        2        +---+                     +---+

   141

STATE   1   +----+   |        +---+   +----+   |

   142

        0 --+        +--------+   +---+        +------

   143

   144

   145

****************************************************************)

   146

   147

   148

FUNCTION_BLOCK TON

   149

  VAR_INPUT

   150

    IN : BOOL;  (* first input parameter *)

   151

    PT : TIME;  (* second input parameter *)

   152

  END_VAR

   153

  VAR_OUTPUT

   154

    Q : BOOL := FALSE;  (* first output parameter *)

   155

    ET : TIME := T#0s;  (* second output parameter *)

   156

  END_VAR

   157

   158

  VAR

   159

    STATE : SINT := 0;  (* internal state: 0-reset, 1-counting, 2-set *)

   160

    PREV_IN : BOOL := FALSE;

   161

    CURRENT_TIME, START_TIME : TIME;

   162

  END_VAR

   163

   164

  {data__->CURRENT_TIME = __CURRENT_TIME;}

   165

   166

  IF ((STATE = 0) AND NOT(PREV_IN) AND IN)   (* found rising edge on IN *)

   167

  THEN

   168

    (* start timer... *)

   169

    STATE := 1;

   170

    Q := FALSE;

   171

    START_TIME := CURRENT_TIME;

   172

   173

  ELSE

   174

    (* STATE is 1 or 2 !! *)

   175

    IF (NOT(IN))

   176

    THEN

   177

      ET := T#0s;

   178

      Q := FALSE;

   179

      STATE := 0;

   180

   181

    ELSIF (STATE = 1)

   182

    THEN

   183

      IF ((START_TIME + PT) <= CURRENT_TIME)

   184

      THEN

   185

        STATE := 2;

   186

        Q := TRUE;

   187

        ET := PT;

   188

      ELSE

   189

        ET := CURRENT_TIME - START_TIME;

   190

      END_IF;

   191

    END_IF;

   192

   193

  END_IF;

   194

   195

  PREV_IN := IN;

   196

   197

END_FUNCTION_BLOCK

   198

   199

   200

   201

   202

   203

(****************************************************************

   204

   205

             TOFF - Off-delay timing - state machine

   206

   207

   208

              +--------+        +---+   +--------+

   209

       IN     |        |        |   |   |        |

   210

           ---+        +--------+   +---+        +-----------

   211

              t0       t1       t2  t3  t4       t5

   212

              +-------------+   +---------------------+

   213

       Q      |             |   |                     |

   214

           ---+             +---+                     +------

   215

              t0          t1+PT t2                  t5+PT

   216

         PT                 +---+                     +------

   217

          :                /    |       +            /

   218

       ET :               /     |      /|           /

   219

          :              /      |     / |          /

   220

          :             /       |    /  |         /

   221

          0------------+        +---+   +--------+

   222

                       t1           t3           t5

   223

   224

   225

        2                   +---+                     +------

   226

STATE   1              +----+   |   +---+        +----+

   227

        0 -------------+        +---+   +--------+

   228

   229

   230

****************************************************************)

   231

   232

FUNCTION_BLOCK TOFF

   233

  VAR_INPUT

   234

    IN : BOOL;  (* first input parameter *)

   235

    PT : TIME;  (* second input parameter *)

   236

  END_VAR

   237

  VAR_OUTPUT

   238

    Q : BOOL := FALSE;  (* first output parameter *)

   239

    ET : TIME := T#0s;  (* second output parameter *)

   240

  END_VAR

   241

   242

  VAR

   243

    STATE : SINT := 0;  (* internal state: 0-reset, 1-counting, 2-set *)

   244

    PREV_IN : BOOL := FALSE;

   245

    CURRENT_TIME, START_TIME : TIME;

   246

  END_VAR

   247

   248

  {data__->CURRENT_TIME = __CURRENT_TIME;}

   249

   250

  IF ((STATE = 0) AND PREV_IN AND NOT(IN))   (* found falling edge on IN *)

   251

  THEN

   252

    (* start timer... *)

   253

    STATE := 1;

   254

    START_TIME := CURRENT_TIME;

   255

   256

  ELSE

   257

    (* STATE is 1 or 2 !! *)

   258

    IF (IN)

   259

    THEN

   260

      ET := T#0s;

   261

      STATE := 0;

   262

   263

    ELSIF (STATE = 1)

   264

    THEN

   265

      IF ((START_TIME + PT) <= CURRENT_TIME)

   266

      THEN

   267

        STATE := 2;

   268

        ET := PT;

   269

      ELSE

   270

        ET := CURRENT_TIME - START_TIME;

   271

      END_IF;

   272

    END_IF;

   273

   274

  END_IF;

   275

   276

  Q := IN OR (STATE = 1);

   277

  PREV_IN := IN;

   278

   279

END_FUNCTION_BLOCK

   280