1

#!/usr/bin/env python

     2

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

     3

     4

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5

#based on the plcopen standard. 

     6

#

     7

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

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

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

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

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

    15

#

    16

#This library 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 GNU

    19

#General Public License for more details.

    20

#

    21

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

    22

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

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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

def get_microseconds(value):

    40

    """

    41

    Function converting time duration expressed in day, second and microseconds

    42

    into one expressed in microseconds

    43

    @param value: Time duration to convert

    44

    @return: Time duration expressed in microsecond

    45

    """

    46

    return float(value.days * DAY + \

    47

                 value.seconds * SECOND + \

    48

                 value.microseconds)

    49

    return 

    50

    51

def generate_time(value):

    52

    """

    53

    Function converting time duration expressed in day, second and microseconds

    54

    into a IEC 61131 TIME literal

    55

    @param value: Time duration to convert

    56

    @return: IEC 61131 TIME literal

    57

    """

    58

    microseconds = get_microseconds(value)

    59

    60

    # Get absolute microseconds value and save if it was negative

    61

    negative = microseconds < 0

    62

    microseconds = abs(microseconds)

    63

    64

    # TIME literal prefix

    65

    data = "T#"

    66

    if negative:

    67

        data += "-"

    68

    69

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

    70

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

    71

    # inhibit formatting until a non-null value is found

    72

    not_null = False

    73

    74

    for val, format in [

    75

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

    76

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

    77

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

    78

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

    79

    80

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

    81

        # value have already be found

    82

        if val > 0 or not_null:

    83

            data += format % val

    84

    85

            # Update non-null variable

    86

            not_null = True

    87

    88

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

    89

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

    90

    91

    return data

    92

    93

def generate_date(value):

    94

    """

    95

    Function converting time duration expressed in day, second and microseconds

    96

    into a IEC 61131 DATE literal

    97

    @param value: Time duration to convert

    98

    @return: IEC 61131 DATE literal

    99

    """

   100

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

   101

   102

def generate_datetime(value):

   103

    """

   104

    Function converting time duration expressed in day, second and microseconds

   105

    into a IEC 61131 DATE_AND_TIME literal

   106

    @param value: Time duration to convert

   107

    @return: IEC 61131 DATE_AND_TIME literal

   108

    """

   109

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

   110

   111

def generate_timeofday(value):

   112

    """

   113

    Function converting time duration expressed in day, second and microseconds

   114

    into a IEC 61131 TIME_OF_DAY literal

   115

    @param value: Time duration to convert

   116

    @return: IEC 61131 TIME_OF_DAY literal

   117

    """

   118

    microseconds = get_microseconds(value)

   119

   120

    # TIME_OF_DAY literal prefix

   121

    data = "TOD#"

   122

   123

    for val, format in [

   124

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

   125

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

   126

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

   127

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

   128

   129

        # Add value to TIME_OF_DAY literal

   130

        data += format % val

   131

   132

    return data

   133

   134

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

   135

# literal stored by type

   136

TYPE_TRANSLATOR = {

   137

    "TIME": generate_time,

   138

    "DATE": generate_date,

   139

    "DT": generate_datetime,

   140

    "TOD": generate_timeofday,

   141

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

   142

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

   143

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

   144

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

   145

   146

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

   147

#                            Debug Data Consumer Class

   148

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

   149

   150

"""

   151

Class that implements an element that consumes debug values

   152

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

   153

refreshing

   154

"""

   155

   156

class DebugDataConsumer:

   157

   158

    def __init__(self):

   159

        """

   160

        Constructor

   161

        """

   162

        # Debug value and forced flag

   163

        self.Value = None

   164

        self.Forced = False

   165

   166

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

   167

        self.LastValue = None

   168

        self.LastForced = False

   169

   170

        # Value IEC data type

   171

        self.DataType = None

   172

   173

        # Flag that value update is inhibited

   174

        self.Inhibited = False

   175

   176

    def Inhibit(self, inhibit):

   177

        """

   178

        Set flag to inhibit or activate value update

   179

        @param inhibit: Inhibit flag

   180

        """

   181

        # Save inhibit flag

   182

        self.Inhibited = inhibit

   183

   184

        # When reactivated update value and forced flag with stored values

   185

        if not inhibit and self.LastValue is not None:

   186

            self.SetForced(self.LastForced)

   187

            self.SetValue(self.LastValue)

   188

   189

            # Reset stored values

   190

            self.LastValue = None

   191

            self.LastForced = False

   192

   193

    def SetDataType(self, data_type):

   194

        """

   195

        Set value IEC data type

   196

        @param data_type: Value IEC data type

   197

        """

   198

        self.DataType = data_type

   199

   200

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

   201

        """

   202

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

   203

        @param tick: PLC tick when value was captured

   204

        @param value: Value captured

   205

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

   206

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

   207

        """

   208

        value, forced = values

   209

   210

        # Translate value to IEC literal

   211

        if self.DataType != raw:

   212

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

   213

   214

        # Store value and forced flag when value update is inhibited

   215

        if self.Inhibited:

   216

            self.LastValue = value

   217

            self.LastForced = forced

   218

   219

        # Update value and forced flag in any other case

   220

        else:

   221

            self.SetForced(forced)

   222

            self.SetValue(value)

   223

   224

    def SetValue(self, value):

   225

        """

   226

        Update value.

   227

        May be overridden by inherited classes

   228

        @param value: New value

   229

        """

   230

        self.Value = value

   231

   232

    def GetValue(self):

   233

        """

   234

        Return current value

   235

        @return: Current value

   236

        """

   237

        return self.Value

   238

   239

    def SetForced(self, forced):

   240

        """

   241

        Update Forced flag.

   242

        May be overridden by inherited classes

   243

        @param forced: New forced flag

   244

        """

   245

        self.Forced = forced

   246

   247

    def IsForced(self):

   248

        """

   249

        Indicate if current value is forced

   250

        @return: Current forced flag

   251

        """

   252

        return self.Forced