1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

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

    15

#

    16

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

    17

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

    18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

import datetime

    26

    27

    28

# -------------------------------------------------------------------------------

    29

#                        Date and Time conversion function

    30

# -------------------------------------------------------------------------------

    31

    32

SECOND = 1000000      # Number of microseconds in one second

    33

MINUTE = 60 * SECOND  # Number of microseconds in one minute

    34

HOUR = 60 * MINUTE    # Number of microseconds in one hour

    35

DAY = 24 * HOUR       # Number of microseconds in one day

    36

    37

# Date corresponding to Epoch (1970 January the first)

    38

DATE_ORIGIN = datetime.datetime(1970, 1, 1)

    39

    40

    41

def get_microseconds(value):

    42

    """

    43

    Function converting time duration expressed in day, second and microseconds

    44

    into one expressed in microseconds

    45

    @param value: Time duration to convert

    46

    @return: Time duration expressed in microsecond

    47

    """

    48

    return float(value.days * DAY +

    49

                 value.seconds * SECOND +

    50

                 value.microseconds)

    51

    52

    53

def generate_time(value):

    54

    """

    55

    Function converting time duration expressed in day, second and microseconds

    56

    into a IEC 61131 TIME literal

    57

    @param value: Time duration to convert

    58

    @return: IEC 61131 TIME literal

    59

    """

    60

    microseconds = get_microseconds(value)

    61

    62

    # Get absolute microseconds value and save if it was negative

    63

    negative = microseconds < 0

    64

    microseconds = abs(microseconds)

    65

    66

    # TIME literal prefix

    67

    data = "T#"

    68

    if negative:

    69

        data += "-"

    70

    71

    # In TIME literal format, it isn't mandatory to indicate null values

    72

    # if no greater non-null values are available. This variable is used to

    73

    # inhibit formatting until a non-null value is found

    74

    not_null = False

    75

    76

    for val, format in [

    77

            (int(microseconds) / DAY, "%dd"),                 # Days

    78

            ((int(microseconds) % DAY) / HOUR, "%dh"),        # Hours

    79

            ((int(microseconds) % HOUR) / MINUTE, "%dm"),     # Minutes

    80

            ((int(microseconds) % MINUTE) / SECOND, "%ds")]:  # Seconds

    81

    82

        # Add value to TIME literal if value is non-null or another non-null

    83

        # value have already be found

    84

        if val > 0 or not_null:

    85

            data += format % val

    86

    87

            # Update non-null variable

    88

            not_null = True

    89

    90

    # In any case microseconds have to be added to TIME literal

    91

    data += "%gms" % (microseconds % SECOND / 1000.)

    92

    93

    return data

    94

    95

    96

def generate_date(value):

    97

    """

    98

    Function converting time duration expressed in day, second and microseconds

    99

    into a IEC 61131 DATE literal

   100

    @param value: Time duration to convert

   101

    @return: IEC 61131 DATE literal

   102

    """

   103

    return (DATE_ORIGIN + value).strftime("DATE#%Y-%m-%d")

   104

   105

   106

def generate_datetime(value):

   107

    """

   108

    Function converting time duration expressed in day, second and microseconds

   109

    into a IEC 61131 DATE_AND_TIME literal

   110

    @param value: Time duration to convert

   111

    @return: IEC 61131 DATE_AND_TIME literal

   112

    """

   113

    return (DATE_ORIGIN + value).strftime("DT#%Y-%m-%d-%H:%M:%S.%f")

   114

   115

   116

def generate_timeofday(value):

   117

    """

   118

    Function converting time duration expressed in day, second and microseconds

   119

    into a IEC 61131 TIME_OF_DAY literal

   120

    @param value: Time duration to convert

   121

    @return: IEC 61131 TIME_OF_DAY literal

   122

    """

   123

    microseconds = get_microseconds(value)

   124

   125

    # TIME_OF_DAY literal prefix

   126

    data = "TOD#"

   127

   128

    for val, format in [

   129

            (int(microseconds) / HOUR, "%2.2d:"),               # Hours

   130

            ((int(microseconds) % HOUR) / MINUTE, "%2.2d:"),    # Minutes

   131

            ((int(microseconds) % MINUTE) / SECOND, "%2.2d."),  # Seconds

   132

            (microseconds % SECOND, "%6.6d")]:                  # Microseconds

   133

   134

        # Add value to TIME_OF_DAY literal

   135

        data += format % val

   136

   137

    return data

   138

   139

   140

# Dictionary of translation functions from value send by debugger to IEC

   141

# literal stored by type

   142

TYPE_TRANSLATOR = {

   143

    "TIME": generate_time,

   144

    "DATE": generate_date,

   145

    "DT": generate_datetime,

   146

    "TOD": generate_timeofday,

   147

    "STRING": lambda v: "'%s'" % v,

   148

    "WSTRING": lambda v: '"%s"' % v,

   149

    "REAL": lambda v: "%.6g" % v,

   150

    "LREAL": lambda v: "%.6g" % v}

   151

   152

   153

# -------------------------------------------------------------------------------

   154

#                            Debug Data Consumer Class

   155

# -------------------------------------------------------------------------------

   156

   157

   158

class DebugDataConsumer(object):

   159

    """

   160

    Class that implements an element that consumes debug values

   161

    Value update can be inhibited during the time the associated Debug Viewer is

   162

    refreshing

   163

    """

   164

   165

    def __init__(self):

   166

        """

   167

        Constructor

   168

        """

   169

        # Debug value and forced flag

   170

        self.Value = None

   171

        self.Forced = False

   172

   173

        # Store debug value and forced flag when value update is inhibited

   174

        self.LastValue = None

   175

        self.LastForced = False

   176

   177

        # Value IEC data type

   178

        self.DataType = None

   179

   180

        # Flag that value update is inhibited

   181

        self.Inhibited = False

   182

   183

    def Inhibit(self, inhibit):

   184

        """

   185

        Set flag to inhibit or activate value update

   186

        @param inhibit: Inhibit flag

   187

        """

   188

        # Save inhibit flag

   189

        self.Inhibited = inhibit

   190

   191

        # When reactivated update value and forced flag with stored values

   192

        if not inhibit and self.LastValue is not None:

   193

            self.SetForced(self.LastForced)

   194

            self.SetValue(self.LastValue)

   195

   196

            # Reset stored values

   197

            self.LastValue = None

   198

            self.LastForced = False

   199

   200

    def SetDataType(self, data_type):

   201

        """

   202

        Set value IEC data type

   203

        @param data_type: Value IEC data type

   204

        """

   205

        self.DataType = data_type

   206

   207

    def NewValues(self, tick, values, raw="BOOL"):

   208

        """

   209

        Function called by debug thread when a new debug value is available

   210

        @param tick: PLC tick when value was captured

   211

        @param value: Value captured

   212

        @param forced: Forced flag, True if value is forced (default: False)

   213

        @param raw: Data type of values not translated (default: 'BOOL')

   214

        """

   215

        value, forced = values

   216

   217

        # Translate value to IEC literal

   218

        if self.DataType != raw:

   219

            value = TYPE_TRANSLATOR.get(self.DataType, str)(value)

   220

   221

        # Store value and forced flag when value update is inhibited

   222

        if self.Inhibited:

   223

            self.LastValue = value

   224

            self.LastForced = forced

   225

   226

        # Update value and forced flag in any other case

   227

        else:

   228

            self.SetForced(forced)

   229

            self.SetValue(value)

   230

   231

    def SetValue(self, value):

   232

        """

   233

        Update value.

   234

        May be overridden by inherited classes

   235

        @param value: New value

   236

        """

   237

        self.Value = value

   238

   239

    def GetValue(self):

   240

        """

   241

        Return current value

   242

        @return: Current value

   243

        """

   244

        return self.Value

   245

   246

    def SetForced(self, forced):

   247

        """

   248

        Update Forced flag.

   249

        May be overridden by inherited classes

   250

        @param forced: New forced flag

   251

        """

   252

        self.Forced = forced

   253

   254

    def IsForced(self):

   255

        """

   256

        Indicate if current value is forced

   257

        @return: Current forced flag

   258

        """

   259

        return self.Forced