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

    return

    52

    53

    54

def generate_time(value):

    55

    """

    56

    Function converting time duration expressed in day, second and microseconds

    57

    into a IEC 61131 TIME literal

    58

    @param value: Time duration to convert

    59

    @return: IEC 61131 TIME literal

    60

    """

    61

    microseconds = get_microseconds(value)

    62

    63

    # Get absolute microseconds value and save if it was negative

    64

    negative = microseconds < 0

    65

    microseconds = abs(microseconds)

    66

    67

    # TIME literal prefix

    68

    data = "T#"

    69

    if negative:

    70

        data += "-"

    71

    72

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

    73

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

    74

    # inhibit formatting until a non-null value is found

    75

    not_null = False

    76

    77

    for val, format in [

    78

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

    79

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

    80

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

    81

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

    82

    83

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

    84

        # value have already be found

    85

        if val > 0 or not_null:

    86

            data += format % val

    87

    88

            # Update non-null variable

    89

            not_null = True

    90

    91

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

    92

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

    93

    94

    return data

    95

    96

    97

def generate_date(value):

    98

    """

    99

    Function converting time duration expressed in day, second and microseconds

   100

    into a IEC 61131 DATE literal

   101

    @param value: Time duration to convert

   102

    @return: IEC 61131 DATE literal

   103

    """

   104

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

   105

   106

   107

def generate_datetime(value):

   108

    """

   109

    Function converting time duration expressed in day, second and microseconds

   110

    into a IEC 61131 DATE_AND_TIME literal

   111

    @param value: Time duration to convert

   112

    @return: IEC 61131 DATE_AND_TIME literal

   113

    """

   114

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

   115

   116

   117

def generate_timeofday(value):

   118

    """

   119

    Function converting time duration expressed in day, second and microseconds

   120

    into a IEC 61131 TIME_OF_DAY literal

   121

    @param value: Time duration to convert

   122

    @return: IEC 61131 TIME_OF_DAY literal

   123

    """

   124

    microseconds = get_microseconds(value)

   125

   126

    # TIME_OF_DAY literal prefix

   127

    data = "TOD#"

   128

   129

    for val, format in [

   130

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

   131

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

   132

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

   133

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

   134

   135

        # Add value to TIME_OF_DAY literal

   136

        data += format % val

   137

   138

    return data

   139

   140

   141

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

   142

# literal stored by type

   143

TYPE_TRANSLATOR = {

   144

    "TIME": generate_time,

   145

    "DATE": generate_date,

   146

    "DT": generate_datetime,

   147

    "TOD": generate_timeofday,

   148

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

   149

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

   150

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

   151

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

   152

   153

   154

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

   155

#                            Debug Data Consumer Class

   156

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

   157

   158

   159

class DebugDataConsumer:

   160

    """

   161

    Class that implements an element that consumes debug values

   162

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

   163

    refreshing

   164

    """

   165

   166

    def __init__(self):

   167

        """

   168

        Constructor

   169

        """

   170

        # Debug value and forced flag

   171

        self.Value = None

   172

        self.Forced = False

   173

   174

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

   175

        self.LastValue = None

   176

        self.LastForced = False

   177

   178

        # Value IEC data type

   179

        self.DataType = None

   180

   181

        # Flag that value update is inhibited

   182

        self.Inhibited = False

   183

   184

    def Inhibit(self, inhibit):

   185

        """

   186

        Set flag to inhibit or activate value update

   187

        @param inhibit: Inhibit flag

   188

        """

   189

        # Save inhibit flag

   190

        self.Inhibited = inhibit

   191

   192

        # When reactivated update value and forced flag with stored values

   193

        if not inhibit and self.LastValue is not None:

   194

            self.SetForced(self.LastForced)

   195

            self.SetValue(self.LastValue)

   196

   197

            # Reset stored values

   198

            self.LastValue = None

   199

            self.LastForced = False

   200

   201

    def SetDataType(self, data_type):

   202

        """

   203

        Set value IEC data type

   204

        @param data_type: Value IEC data type

   205

        """

   206

        self.DataType = data_type

   207

   208

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

   209

        """

   210

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

   211

        @param tick: PLC tick when value was captured

   212

        @param value: Value captured

   213

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

   214

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

   215

        """

   216

        value, forced = values

   217

   218

        # Translate value to IEC literal

   219

        if self.DataType != raw:

   220

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

   221

   222

        # Store value and forced flag when value update is inhibited

   223

        if self.Inhibited:

   224

            self.LastValue = value

   225

            self.LastForced = forced

   226

   227

        # Update value and forced flag in any other case

   228

        else:

   229

            self.SetForced(forced)

   230

            self.SetValue(value)

   231

   232

    def SetValue(self, value):

   233

        """

   234

        Update value.

   235

        May be overridden by inherited classes

   236

        @param value: New value

   237

        """

   238

        self.Value = value

   239

   240

    def GetValue(self):

   241

        """

   242

        Return current value

   243

        @return: Current value

   244

        """

   245

        return self.Value

   246

   247

    def SetForced(self, forced):

   248

        """

   249

        Update Forced flag.

   250

        May be overridden by inherited classes

   251

        @param forced: New forced flag

   252

        """

   253

        self.Forced = forced

   254

   255

    def IsForced(self):

   256

        """

   257

        Indicate if current value is forced

   258

        @return: Current forced flag

   259

        """

   260

        return self.Forced