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

#                        Date and Time conversion function

    29

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

    30

    31

SECOND = 1000000      # Number of microseconds in one second

    32

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

    33

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

    34

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

    35

    36

# Date corresponding to Epoch (1970 January the first)

    37

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

    38

    39

    40

def get_microseconds(value):

    41

    """

    42

    Function converting time duration expressed in day, second and microseconds

    43

    into one expressed in microseconds

    44

    @param value: Time duration to convert

    45

    @return: Time duration expressed in microsecond

    46

    """

    47

    return float(value.days * DAY + \

    48

                 value.seconds * SECOND + \

    49

                 value.microseconds)

    50

    return

    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

#                            Debug Data Consumer Class

   154

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

   155

   156

   157

class DebugDataConsumer:

   158

    """

   159

    Class that implements an element that consumes debug values

   160

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

   161

    refreshing

   162

    """

   163

   164

    def __init__(self):

   165

        """

   166

        Constructor

   167

        """

   168

        # Debug value and forced flag

   169

        self.Value = None

   170

        self.Forced = False

   171

   172

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

   173

        self.LastValue = None

   174

        self.LastForced = False

   175

   176

        # Value IEC data type

   177

        self.DataType = None

   178

   179

        # Flag that value update is inhibited

   180

        self.Inhibited = False

   181

   182

    def Inhibit(self, inhibit):

   183

        """

   184

        Set flag to inhibit or activate value update

   185

        @param inhibit: Inhibit flag

   186

        """

   187

        # Save inhibit flag

   188

        self.Inhibited = inhibit

   189

   190

        # When reactivated update value and forced flag with stored values

   191

        if not inhibit and self.LastValue is not None:

   192

            self.SetForced(self.LastForced)

   193

            self.SetValue(self.LastValue)

   194

   195

            # Reset stored values

   196

            self.LastValue = None

   197

            self.LastForced = False

   198

   199

    def SetDataType(self, data_type):

   200

        """

   201

        Set value IEC data type

   202

        @param data_type: Value IEC data type

   203

        """

   204

        self.DataType = data_type

   205

   206

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

   207

        """

   208

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

   209

        @param tick: PLC tick when value was captured

   210

        @param value: Value captured

   211

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

   212

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

   213

        """

   214

        value, forced = values

   215

   216

        # Translate value to IEC literal

   217

        if self.DataType != raw:

   218

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

   219

   220

        # Store value and forced flag when value update is inhibited

   221

        if self.Inhibited:

   222

            self.LastValue = value

   223

            self.LastForced = forced

   224

   225

        # Update value and forced flag in any other case

   226

        else:

   227

            self.SetForced(forced)

   228

            self.SetValue(value)

   229

   230

    def SetValue(self, value):

   231

        """

   232

        Update value.

   233

        May be overridden by inherited classes

   234

        @param value: New value

   235

        """

   236

        self.Value = value

   237

   238

    def GetValue(self):

   239

        """

   240

        Return current value

   241

        @return: Current value

   242

        """

   243

        return self.Value

   244

   245

    def SetForced(self, forced):

   246

        """

   247

        Update Forced flag.

   248

        May be overridden by inherited classes

   249

        @param forced: New forced flag

   250

        """

   251

        self.Forced = forced

   252

   253

    def IsForced(self):

   254

        """

   255

        Indicate if current value is forced

   256

        @return: Current forced flag

   257

        """

   258

        return self.Forced