1

#!/usr/bin/env python

     2

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

     3

#

     4

# See COPYING.Runtime file for copyrights details.

     5

#

     6

     7

from ctypes import *

     8

from datetime import timedelta as td

     9

    10

class IEC_STRING(Structure):

    11

    """

    12

    Must be changed according to changes in iec_types.h

    13

    """

    14

    _fields_ = [("len", c_uint8),

    15

                ("body", c_char * 126)]

    16

    17

    18

class IEC_TIME(Structure):

    19

    """

    20

    Must be changed according to changes in iec_types.h

    21

    """

    22

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

    23

                ("ns", c_long)]  # tv_nsec

    24

    25

    26

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

    27

    return (t, u, p)

    28

    29

    30

def _ttime():

    31

    return (IEC_TIME,

    32

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

    33

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

    34

    35

    36

SameEndianessTypeTranslator = {

    37

    "BOOL":       _t(c_uint8, lambda x: bool(x.value)),

    38

    "STEP":       _t(c_uint8),

    39

    "TRANSITION": _t(c_uint8),

    40

    "ACTION":     _t(c_uint8),

    41

    "SINT":       _t(c_int8),

    42

    "USINT":      _t(c_uint8),

    43

    "BYTE":       _t(c_uint8),

    44

    "STRING":     (IEC_STRING,

    45

                   lambda x: x.body[:x.len].decode(),

    46

                   lambda t, x: t(len(x), x.encode() if type(x)==str else x)),

    47

    "INT":        _t(c_int16),

    48

    "UINT":       _t(c_uint16),

    49

    "WORD":       _t(c_uint16),

    50

    "DINT":       _t(c_int32),

    51

    "UDINT":      _t(c_uint32),

    52

    "DWORD":      _t(c_uint32),

    53

    "LINT":       _t(c_int64),

    54

    "ULINT":      _t(c_uint64),

    55

    "LWORD":      _t(c_uint64),

    56

    "REAL":       _t(c_float),

    57

    "LREAL":      _t(c_double),

    58

    "TIME":       _ttime(),

    59

    "TOD":        _ttime(),

    60

    "DATE":       _ttime(),

    61

    "DT":         _ttime(),

    62

    }

    63

    64

SwapedEndianessTypeTranslator = {

    65

    # TODO

    66

    }

    67

    68

TypeTranslator = SameEndianessTypeTranslator

    69

    70

# Construct debugger natively supported types

    71

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

    72

    73

    74

def UnpackDebugBuffer(buff, indexes):

    75

    res = []

    76

    buffoffset = 0

    77

    buffsize = len(buff)

    78

    buffptr = cast(cast(buff, c_char_p), c_void_p).value

    79

    for iectype in indexes:

    80

        c_type, unpack_func, _pack_func = TypeTranslator.get(iectype,

    81

                                                             (None, None, None))

    82

    83

        cursor = c_void_p(buffptr + buffoffset)

    84

        if iectype == "STRING":

    85

            # strlen is stored in c_uint8 and sizeof(c_uint8) is 1

    86

            # first check we can read size

    87

            if (buffoffset + 1) <= buffsize:

    88

                size = 1 + cast(cursor,POINTER(c_type)).contents.len

    89

            else:

    90

                return None

    91

        else:

    92

            size = sizeof(c_type)

    93

    94

        if c_type is not None and (buffoffset + size) <= buffsize:

    95

            ptr = cast(cursor, POINTER(c_type))

    96

            value = unpack_func(ptr.contents)

    97

            buffoffset += size

    98

            res.append(value)

    99

        else:

   100

            return None

   101

    if buffoffset and buffoffset == buffsize:

   102

        return res

   103

    return None

   104

   105

def ValueToIECBytes(iectype, value):

   106

    if value is None:

   107

        return None

   108

    c_type, _unpack_func, pack_func = TypeTranslator[iectype]

   109

    return bytes(pack_func(c_type, value))