1

(*

     2

 *  This file is part of matiec - a compiler for the programming

     3

 *  languages defined in IEC 61131-3

     4

 *

     5

 *  Copyright (C) 2011  Mario de Sousa (msousa@fe.up.pt)

     6

 *

     7

 * See COPYING and COPYING.LESSER files for copyright details.

     8

 * This library is free software; you can redistribute it and/or

     9

 * modify it under the terms of the GNU Lesser General Public

    10

 * License as published by the Free Software Foundation; either

    11

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

    12

 *

    13

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

    14

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

    15

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

    16

 * Lesser General Public License for more details.

    17

 * 

    18

 * You should have received a copy of the GNU Lesser General Public

    19

 * License along with this library; if not, write to the Free Software

    20

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307

    21

 * USA

    22

 *

    23

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

    24

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

    25

 *)

    26

    27

(*

    28

 * An IEC 61131-3 compiler.

    29

 *

    30

 * Based on the

    31

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

    32

 *

    33

 *)

    34

    35

(*

    36

 * This is part of the library conatining the functions

    37

 * and function blocks defined in the standard.

    38

 *

    39

 * Timer Function Blocks

    40

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

    41

 *

    42

 * NOTE: The timing diagrams in the comments (except the state variable) 

    43

 *       were taken from the IEC 61131-3 standard.

    44

 *)

    45

    46

    47

    48

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

    49

    50

                  TP - pulse timing - state machine

    51

    52

    53

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

    54

       IN   |        |     || ||   |        |

    55

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

    56

            t0       t1    t2 t3    t4       t5

    57

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

    58

       Q    |    |         |    |  |    |

    59

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

    60

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

    61

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

    62

          :     /    |         /|      /    |

    63

       ET :    /     |        / |     /     |

    64

          :   /      |       /  |    /      |

    65

          :  /       |      /   |   /       |

    66

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

    67

            t0       t1    t2      t4       t5

    68

    69

    70

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

    71

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

    72

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

    73

    74

    75

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

    76

    77

FUNCTION_BLOCK TP

    78

  VAR_INPUT

    79

    IN : BOOL;  (* first input parameter *)

    80

    PT : TIME;  (* second input parameter *)

    81

  END_VAR

    82

  VAR_OUTPUT

    83

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

    84

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

    85

  END_VAR

    86

    87

  VAR

    88

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

    89

    PREV_IN : BOOL := FALSE;

    90

    CURRENT_TIME, START_TIME : TIME;

    91

  END_VAR

    92

    93

  {__SET_VAR(data__->,CURRENT_TIME,__CURRENT_TIME)}

    94

    95

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

    96

  THEN

    97

    (* start timer... *)

    98

    STATE := 1;

    99

    Q := TRUE;

   100

    START_TIME := CURRENT_TIME;

   101

   102

  ELSIF (STATE = 1)

   103

  THEN

   104

    IF ((START_TIME + PT) <= CURRENT_TIME)

   105

    THEN

   106

      STATE := 2;

   107

      Q := FALSE;

   108

      ET := PT;

   109

    ELSE

   110

      ET := CURRENT_TIME - START_TIME;

   111

    END_IF;

   112

  END_IF;

   113

   114

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

   115

  THEN

   116

    ET := T#0s;

   117

    STATE := 0;

   118

  END_IF;

   119

   120

   121

  PREV_IN := IN;

   122

   123

END_FUNCTION_BLOCK

   124

   125

   126

   127

   128

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

   129

   130

             TON - On-delay timing - state machine

   131

   132

   133

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

   134

       IN   |        |        |   |   |        |

   135

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

   136

            t0       t1       t2  t3  t4       t5

   137

                 +---+                     +---+

   138

       Q         |   |                     |   |

   139

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

   140

              t0+PT  t1                t4+PT   t5

   141

         PT      +---+                     +---+

   142

          :     /    |            +       /    |

   143

       ET :    /     |           /|      /     |

   144

          :   /      |          / |     /      |

   145

          :  /       |         /  |    /       |

   146

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

   147

            t0       t1       t2  t3  t4       t5

   148

   149

   150

        2        +---+                     +---+

   151

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

   152

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

   153

   154

   155

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

   156

   157

   158

FUNCTION_BLOCK TON

   159

  VAR_INPUT

   160

    IN : BOOL;  (* first input parameter *)

   161

    PT : TIME;  (* second input parameter *)

   162

  END_VAR

   163

  VAR_OUTPUT

   164

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

   165

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

   166

  END_VAR

   167

   168

  VAR

   169

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

   170

    PREV_IN : BOOL := FALSE;

   171

    CURRENT_TIME, START_TIME : TIME;

   172

  END_VAR

   173

   174

  {__SET_VAR(data__->,CURRENT_TIME,__CURRENT_TIME)}

   175

   176

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

   177

  THEN

   178

    (* start timer... *)

   179

    STATE := 1;

   180

    Q := FALSE;

   181

    START_TIME := CURRENT_TIME;

   182

   183

  ELSE

   184

    (* STATE is 1 or 2 !! *)

   185

    IF (NOT(IN))

   186

    THEN

   187

      ET := T#0s;

   188

      Q := FALSE;

   189

      STATE := 0;

   190

   191

    ELSIF (STATE = 1)

   192

    THEN

   193

      IF ((START_TIME + PT) <= CURRENT_TIME)

   194

      THEN

   195

        STATE := 2;

   196

        Q := TRUE;

   197

        ET := PT;

   198

      ELSE

   199

        ET := CURRENT_TIME - START_TIME;

   200

      END_IF;

   201

    END_IF;

   202

   203

  END_IF;

   204

   205

  PREV_IN := IN;

   206

   207

END_FUNCTION_BLOCK

   208

   209

   210

   211

   212

   213

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

   214

   215

             TOF - Off-delay timing - state machine

   216

   217

   218

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

   219

       IN     |        |        |   |   |        |

   220

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

   221

              t0       t1       t2  t3  t4       t5

   222

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

   223

       Q      |             |   |                     |

   224

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

   225

              t0          t1+PT t2                  t5+PT

   226

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

   227

          :                /    |       +            /

   228

       ET :               /     |      /|           /

   229

          :              /      |     / |          /

   230

          :             /       |    /  |         /

   231

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

   232

                       t1           t3           t5

   233

   234

   235

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

   236

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

   237

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

   238

   239

   240

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

   241

   242

FUNCTION_BLOCK TOF

   243

  VAR_INPUT

   244

    IN : BOOL;  (* first input parameter *)

   245

    PT : TIME;  (* second input parameter *)

   246

  END_VAR

   247

  VAR_OUTPUT

   248

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

   249

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

   250

  END_VAR

   251

   252

  VAR

   253

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

   254

    PREV_IN : BOOL := FALSE;

   255

    CURRENT_TIME, START_TIME : TIME;

   256

  END_VAR

   257

   258

  {__SET_VAR(data__->,CURRENT_TIME,__CURRENT_TIME)}

   259

   260

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

   261

  THEN

   262

    (* start timer... *)

   263

    STATE := 1;

   264

    START_TIME := CURRENT_TIME;

   265

   266

  ELSE

   267

    (* STATE is 1 or 2 !! *)

   268

    IF (IN)

   269

    THEN

   270

      ET := T#0s;

   271

      STATE := 0;

   272

   273

    ELSIF (STATE = 1)

   274

    THEN

   275

      IF ((START_TIME + PT) <= CURRENT_TIME)

   276

      THEN

   277

        STATE := 2;

   278

        ET := PT;

   279

      ELSE

   280

        ET := CURRENT_TIME - START_TIME;

   281

      END_IF;

   282

    END_IF;

   283

   284

  END_IF;

   285

   286

  Q := IN OR (STATE = 1);

   287

  PREV_IN := IN;

   288

   289

END_FUNCTION_BLOCK

   290