1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz, runtime and an Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

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

     8

#

     9

# See COPYING.Runtime 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 Lesser 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

# Lesser General Public License for more details.

    20

    21

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

    22

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

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

    24

    25

import ctypes

    26

ctypes.pythonapi.PyString_AsString.argtypes = (ctypes.c_void_p,)

    27

ctypes.pythonapi.PyString_AsString.restype = ctypes.POINTER(ctypes.c_char)

    28

    29

    30

from ctypes import *

    31

from datetime import timedelta as td

    32

    33

class IEC_STRING(Structure):

    34

    """

    35

    Must be changed according to changes in iec_types.h

    36

    """

    37

    _fields_ = [("len", c_uint8),

    38

                ("body", c_char * 126)]

    39

    40

class IEC_TIME(Structure):

    41

    """

    42

    Must be changed according to changes in iec_types.h

    43

    """

    44

    _fields_ = [("s", c_long), #tv_sec

    45

                ("ns", c_long)] #tv_nsec

    46

    47

def _t(t, u=lambda x:x.value, p=lambda t,x:t(x)): return  (t, u, p)

    48

def _ttime(): return (IEC_TIME,

    49

                      lambda x:td(0, x.s, x.ns/1000),

    50

                      lambda t,x:t(x.days * 24 * 3600 + x.seconds, x.microseconds*1000))

    51

    52

SameEndianessTypeTranslator = {

    53

    "BOOL" :       _t(c_uint8,  lambda x:x.value!=0),

    54

    "STEP" :       _t(c_uint8),

    55

    "TRANSITION" : _t(c_uint8),

    56

    "ACTION" :     _t(c_uint8),

    57

    "SINT" :       _t(c_int8),

    58

    "USINT" :      _t(c_uint8),

    59

    "BYTE" :       _t(c_uint8),

    60

    "STRING" :     (IEC_STRING,

    61

                      lambda x:x.body[:x.len],

    62

                      lambda t,x:t(len(x),x)),

    63

    "INT" :        _t(c_int16),

    64

    "UINT" :       _t(c_uint16),

    65

    "WORD" :       _t(c_uint16),

    66

    "DINT" :       _t(c_int32),

    67

    "UDINT" :      _t(c_uint32),

    68

    "DWORD" :      _t(c_uint32),

    69

    "LINT" :       _t(c_int64),

    70

    "ULINT" :      _t(c_uint64),

    71

    "LWORD" :      _t(c_uint64),

    72

    "REAL" :       _t(c_float),

    73

    "LREAL" :      _t(c_double),

    74

    "TIME" :       _ttime(),

    75

    "TOD" :        _ttime(),

    76

    "DATE" :       _ttime(),

    77

    "DT" :         _ttime(),

    78

    }

    79

    80

SwapedEndianessTypeTranslator = {

    81

    #TODO

    82

    }

    83

    84

TypeTranslator=SameEndianessTypeTranslator

    85

    86

# Construct debugger natively supported types

    87

DebugTypesSize =  dict([(key,sizeof(t)) for key,(t,p,u) in SameEndianessTypeTranslator.iteritems() if t is not None])

    88

    89

def UnpackDebugBuffer(buff, indexes):

    90

    res =  []

    91

    buffoffset = 0

    92

    buffsize = len(buff)

    93

    buffptr = cast(ctypes.pythonapi.PyString_AsString(id(buff)),c_void_p).value

    94

    for iectype in indexes:

    95

        c_type,unpack_func, pack_func = \

    96

            TypeTranslator.get(iectype,

    97

                                    (None,None,None))

    98

        if c_type is not None and buffoffset < buffsize:

    99

            cursor = c_void_p( buffptr + buffoffset)

   100

            value = unpack_func( cast(cursor,

   101

                         POINTER(c_type)).contents)

   102

            buffoffset += sizeof(c_type) if iectype != "STRING" else len(value)+1

   103

            res.append(value)

   104

        else:

   105

            break

   106

    if buffoffset and buffoffset == buffsize:

   107

        return res

   108

    return None

   109

   110

   111

   112

LogLevels = ["CRITICAL","WARNING","INFO","DEBUG"]

   113

LogLevelsCount = len(LogLevels)

   114

LogLevelsDict = dict(zip(LogLevels,range(LogLevelsCount)))

   115

LogLevelsDefault = LogLevelsDict["DEBUG"]

   116