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

    26

from __future__ import absolute_import

    27

import datetime

    28

    29

    30

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

    31

#                        Date and Time conversion function

    32

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

    33

    34

SECOND = 1000000      # Number of microseconds in one second

    35

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

    36

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

    37

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

    38

    39

# Date corresponding to Epoch (1970 January the first)

    40

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

    41

    42

    43

def get_microseconds(value):

    44

    """

    45

    Function converting time duration expressed in day, second and microseconds

    46

    into one expressed in microseconds

    47

    @param value: Time duration to convert

    48

    @return: Time duration expressed in microsecond

    49

    """

    50

    return float(value.days * DAY +

    51

                 value.seconds * SECOND +

    52

                 value.microseconds)

    53

    54

    55

def generate_time(value):

    56

    """

    57

    Function converting time duration expressed in day, second and microseconds

    58

    into a IEC 61131 TIME literal

    59

    @param value: Time duration to convert

    60

    @return: IEC 61131 TIME literal

    61

    """

    62

    microseconds = get_microseconds(value)

    63

    64

    # Get absolute microseconds value and save if it was negative

    65

    negative = microseconds < 0

    66

    microseconds = abs(microseconds)

    67

    68

    # TIME literal prefix

    69

    data = "T#"

    70

    if negative:

    71

        data += "-"

    72

    73

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

    74

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

    75

    # inhibit formatting until a non-null value is found

    76

    not_null = False

    77

    78

    for val, format in [

    79

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

    80

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

    81

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

    82

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

    83

    84

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

    85

        # value have already be found

    86

        if val > 0 or not_null:

    87

            data += format % val

    88

    89

            # Update non-null variable

    90

            not_null = True

    91

    92

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

    93

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

    94

    95

    return data

    96

    97

    98

def generate_date(value):

    99

    """

   100

    Function converting time duration expressed in day, second and microseconds

   101

    into a IEC 61131 DATE literal

   102

    @param value: Time duration to convert

   103

    @return: IEC 61131 DATE literal

   104

    """

   105

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

   106

   107

   108

def generate_datetime(value):

   109

    """

   110

    Function converting time duration expressed in day, second and microseconds

   111

    into a IEC 61131 DATE_AND_TIME literal

   112

    @param value: Time duration to convert

   113

    @return: IEC 61131 DATE_AND_TIME literal

   114

    """

   115

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

   116

   117

   118

def generate_timeofday(value):

   119

    """

   120

    Function converting time duration expressed in day, second and microseconds

   121

    into a IEC 61131 TIME_OF_DAY literal

   122

    @param value: Time duration to convert

   123

    @return: IEC 61131 TIME_OF_DAY literal

   124

    """

   125

    microseconds = get_microseconds(value)

   126

   127

    # TIME_OF_DAY literal prefix

   128

    data = "TOD#"

   129

   130

    for val, format in [

   131

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

   132

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

   133

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

   134

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

   135

   136

        # Add value to TIME_OF_DAY literal

   137

        data += format % val

   138

   139

    return data

   140

   141

   142

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

   143

# literal stored by type

   144

TYPE_TRANSLATOR = {

   145

    "TIME": generate_time,

   146

    "DATE": generate_date,

   147

    "DT": generate_datetime,

   148

    "TOD": generate_timeofday,

   149

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

   150

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

   151

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

   152

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

   153

   154

   155

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

   156

#                            Debug Data Consumer Class

   157

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

   158

   159

   160

class DebugDataConsumer(object):

   161

    """

   162

    Class that implements an element that consumes debug values

   163

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

   164

    refreshing

   165

    """

   166

   167

    def __init__(self):

   168

        """

   169

        Constructor

   170

        """

   171

        # Debug value and forced flag

   172

        self.Value = None

   173

        self.Forced = False

   174

   175

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

   176

        self.LastValue = None

   177

        self.LastForced = False

   178

   179

        # Value IEC data type

   180

        self.DataType = None

   181

   182

        # Flag that value update is inhibited

   183

        self.Inhibited = False

   184

   185

    def Inhibit(self, inhibit):

   186

        """

   187

        Set flag to inhibit or activate value update

   188

        @param inhibit: Inhibit flag

   189

        """

   190

        # Save inhibit flag

   191

        self.Inhibited = inhibit

   192

   193

        # When reactivated update value and forced flag with stored values

   194

        if not inhibit and self.LastValue is not None:

   195

            self.SetForced(self.LastForced)

   196

            self.SetValue(self.LastValue)

   197

   198

            # Reset stored values

   199

            self.LastValue = None

   200

            self.LastForced = False

   201

   202

    def SetDataType(self, data_type):

   203

        """

   204

        Set value IEC data type

   205

        @param data_type: Value IEC data type

   206

        """

   207

        self.DataType = data_type

   208

   209

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

   210

        """

   211

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

   212

        @param tick: PLC tick when value was captured

   213

        @param value: Value captured

   214

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

   215

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

   216

        """

   217

        value, forced = values

   218

   219

        # Translate value to IEC literal

   220

        if self.DataType != raw:

   221

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

   222

   223

        # Store value and forced flag when value update is inhibited

   224

        if self.Inhibited:

   225

            self.LastValue = value

   226

            self.LastForced = forced

   227

   228

        # Update value and forced flag in any other case

   229

        else:

   230

            self.SetForced(forced)

   231

            self.SetValue(value)

   232

   233

    def SetValue(self, value):

   234

        """

   235

        Update value.

   236

        May be overridden by inherited classes

   237

        @param value: New value

   238

        """

   239

        self.Value = value

   240

   241

    def GetValue(self):

   242

        """

   243

        Return current value

   244

        @return: Current value

   245

        """

   246

        return self.Value

   247

   248

    def SetForced(self, forced):

   249

        """

   250

        Update Forced flag.

   251

        May be overridden by inherited classes

   252

        @param forced: New forced flag

   253

        """

   254

        self.Forced = forced

   255

   256

    def IsForced(self):

   257

        """

   258

        Indicate if current value is forced

   259

        @return: Current forced flag

   260

        """

   261

        return self.Forced