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 [

    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

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

   140

# literal stored by type

   141

TYPE_TRANSLATOR = {

   142

    "TIME": generate_time,

   143

    "DATE": generate_date,

   144

    "DT": generate_datetime,

   145

    "TOD": generate_timeofday,

   146

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

   147

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

   148

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

   149

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

   150

   151

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

   152

#                            Debug Data Consumer Class

   153

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

   154

   155

   156

class DebugDataConsumer:

   157

    """

   158

    Class that implements an element that consumes debug values

   159

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

   160

    refreshing

   161

    """

   162

   163

    def __init__(self):

   164

        """

   165

        Constructor

   166

        """

   167

        # Debug value and forced flag

   168

        self.Value = None

   169

        self.Forced = False

   170

   171

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

   172

        self.LastValue = None

   173

        self.LastForced = False

   174

   175

        # Value IEC data type

   176

        self.DataType = None

   177

   178

        # Flag that value update is inhibited

   179

        self.Inhibited = False

   180

   181

    def Inhibit(self, inhibit):

   182

        """

   183

        Set flag to inhibit or activate value update

   184

        @param inhibit: Inhibit flag

   185

        """

   186

        # Save inhibit flag

   187

        self.Inhibited = inhibit

   188

   189

        # When reactivated update value and forced flag with stored values

   190

        if not inhibit and self.LastValue is not None:

   191

            self.SetForced(self.LastForced)

   192

            self.SetValue(self.LastValue)

   193

   194

            # Reset stored values

   195

            self.LastValue = None

   196

            self.LastForced = False

   197

   198

    def SetDataType(self, data_type):

   199

        """

   200

        Set value IEC data type

   201

        @param data_type: Value IEC data type

   202

        """

   203

        self.DataType = data_type

   204

   205

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

   206

        """

   207

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

   208

        @param tick: PLC tick when value was captured

   209

        @param value: Value captured

   210

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

   211

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

   212

        """

   213

        value, forced = values

   214

   215

        # Translate value to IEC literal

   216

        if self.DataType != raw:

   217

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

   218

   219

        # Store value and forced flag when value update is inhibited

   220

        if self.Inhibited:

   221

            self.LastValue = value

   222

            self.LastForced = forced

   223

   224

        # Update value and forced flag in any other case

   225

        else:

   226

            self.SetForced(forced)

   227

            self.SetValue(value)

   228

   229

    def SetValue(self, value):

   230

        """

   231

        Update value.

   232

        May be overridden by inherited classes

   233

        @param value: New value

   234

        """

   235

        self.Value = value

   236

   237

    def GetValue(self):

   238

        """

   239

        Return current value

   240

        @return: Current value

   241

        """

   242

        return self.Value

   243

   244

    def SetForced(self, forced):

   245

        """

   246

        Update Forced flag.

   247

        May be overridden by inherited classes

   248

        @param forced: New forced flag

   249

        """

   250

        self.Forced = forced

   251

   252

    def IsForced(self):

   253

        """

   254

        Indicate if current value is forced

   255

        @return: Current forced flag

   256

        """

   257

        return self.Forced