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

from __future__ import division

    28

import datetime

    29

    30

    31

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

    32

#                        Date and Time conversion function

    33

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

    34

    35

SECOND = 1000000      # Number of microseconds in one second

    36

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

    37

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

    38

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

    39

    40

# Date corresponding to Epoch (1970 January the first)

    41

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

    42

    43

    44

def get_microseconds(value):

    45

    """

    46

    Function converting time duration expressed in day, second and microseconds

    47

    into one expressed in microseconds

    48

    @param value: Time duration to convert

    49

    @return: Time duration expressed in microsecond

    50

    """

    51

    return float(value.days * DAY +

    52

                 value.seconds * SECOND +

    53

                 value.microseconds)

    54

    55

    56

def generate_time(value):

    57

    """

    58

    Function converting time duration expressed in day, second and microseconds

    59

    into a IEC 61131 TIME literal

    60

    @param value: Time duration to convert

    61

    @return: IEC 61131 TIME literal

    62

    """

    63

    microseconds = get_microseconds(value)

    64

    65

    # Get absolute microseconds value and save if it was negative

    66

    negative = microseconds < 0

    67

    microseconds = abs(microseconds)

    68

    69

    # TIME literal prefix

    70

    data = "T#"

    71

    if negative:

    72

        data += "-"

    73

    74

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

    75

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

    76

    # inhibit formatting until a non-null value is found

    77

    not_null = False

    78

    79

    for val, format in [

    80

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

    81

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

    82

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

    83

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

    84

    85

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

    86

        # value have already be found

    87

        if val > 0 or not_null:

    88

            data += format % val

    89

    90

            # Update non-null variable

    91

            not_null = True

    92

    93

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

    94

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

    95

    96

    return data

    97

    98

    99

def generate_date(value):

   100

    """

   101

    Function converting time duration expressed in day, second and microseconds

   102

    into a IEC 61131 DATE literal

   103

    @param value: Time duration to convert

   104

    @return: IEC 61131 DATE literal

   105

    """

   106

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

   107

   108

   109

def generate_datetime(value):

   110

    """

   111

    Function converting time duration expressed in day, second and microseconds

   112

    into a IEC 61131 DATE_AND_TIME literal

   113

    @param value: Time duration to convert

   114

    @return: IEC 61131 DATE_AND_TIME literal

   115

    """

   116

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

   117

   118

   119

def generate_timeofday(value):

   120

    """

   121

    Function converting time duration expressed in day, second and microseconds

   122

    into a IEC 61131 TIME_OF_DAY literal

   123

    @param value: Time duration to convert

   124

    @return: IEC 61131 TIME_OF_DAY literal

   125

    """

   126

    microseconds = get_microseconds(value)

   127

   128

    # TIME_OF_DAY literal prefix

   129

    data = "TOD#"

   130

   131

    for val, format in [

   132

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

   133

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

   134

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

   135

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

   136

   137

        # Add value to TIME_OF_DAY literal

   138

        data += format % val

   139

   140

    return data

   141

   142

   143

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

   144

# literal stored by type

   145

TYPE_TRANSLATOR = {

   146

    "TIME": generate_time,

   147

    "DATE": generate_date,

   148

    "DT": generate_datetime,

   149

    "TOD": generate_timeofday,

   150

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

   151

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

   152

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

   153

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

   154

   155

   156

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

   157

#                            Debug Data Consumer Class

   158

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

   159

   160

   161

class DebugDataConsumer(object):

   162

    """

   163

    Class that implements an element that consumes debug values

   164

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

   165

    refreshing

   166

    """

   167

   168

    def __init__(self):

   169

        """

   170

        Constructor

   171

        """

   172

        # Debug value and forced flag

   173

        self.Value = None

   174

        self.Forced = False

   175

   176

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

   177

        self.LastValue = None

   178

        self.LastForced = False

   179

   180

        # Value IEC data type

   181

        self.DataType = None

   182

   183

        # Flag that value update is inhibited

   184

        self.Inhibited = False

   185

   186

    def Inhibit(self, inhibit):

   187

        """

   188

        Set flag to inhibit or activate value update

   189

        @param inhibit: Inhibit flag

   190

        """

   191

        # Save inhibit flag

   192

        self.Inhibited = inhibit

   193

   194

        # When reactivated update value and forced flag with stored values

   195

        if not inhibit and self.LastValue is not None:

   196

            self.SetForced(self.LastForced)

   197

            self.SetValue(self.LastValue)

   198

   199

            # Reset stored values

   200

            self.LastValue = None

   201

            self.LastForced = False

   202

   203

    def SetDataType(self, data_type):

   204

        """

   205

        Set value IEC data type

   206

        @param data_type: Value IEC data type

   207

        """

   208

        self.DataType = data_type

   209

   210

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

   211

        """

   212

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

   213

        @param tick: PLC tick when value was captured

   214

        @param value: Value captured

   215

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

   216

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

   217

        """

   218

        value, forced = values

   219

   220

        # Translate value to IEC literal

   221

        if self.DataType != raw:

   222

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

   223

   224

        # Store value and forced flag when value update is inhibited

   225

        if self.Inhibited:

   226

            self.LastValue = value

   227

            self.LastForced = forced

   228

   229

        # Update value and forced flag in any other case

   230

        else:

   231

            self.SetForced(forced)

   232

            self.SetValue(value)

   233

   234

    def SetValue(self, value):

   235

        """

   236

        Update value.

   237

        May be overridden by inherited classes

   238

        @param value: New value

   239

        """

   240

        self.Value = value

   241

   242

    def GetValue(self):

   243

        """

   244

        Return current value

   245

        @return: Current value

   246

        """

   247

        return self.Value

   248

   249

    def SetForced(self, forced):

   250

        """

   251

        Update Forced flag.

   252

        May be overridden by inherited classes

   253

        @param forced: New forced flag

   254

        """

   255

        self.Forced = forced

   256

   257

    def IsForced(self):

   258

        """

   259

        Indicate if current value is forced

   260

        @return: Current forced flag

   261

        """

   262

        return self.Forced