1

import subprocess,sys,ctypes

     2

from threading import Thread

     3

import ctypes,time,re

     4

     5

SDOAnswered = PLCBinary.SDOAnswered

     6

SDOAnswered.restype = None

     7

SDOAnswered.argtypes = []

     8

     9

SDOThread = None

    10

Result = None

    11

    12

def SDOThreadProc(*params):

    13

    global Result

    14

    if params[0] == "upload":

    15

        command = "ethercat upload -p %d -t %s 0x%.4x 0x%.2x"

    16

    else:

    17

        command = "ethercat download -p %d -t %s 0x%.4x 0x%.2x %s"

    18

    19

    proc = subprocess.Popen(command % params[1:], stdout=subprocess.PIPE, shell=True)

    20

    res = proc.wait()

    21

    output = proc.communicate()[0]

    22

    23

    if params[0] == "upload":

    24

        Result = None

    25

        if res == 0:

    26

            if params[2] in ["float", "double"]:

    27

                Result = float(output)

    28

            elif params[2] in ["string", "octet_string", "unicode_string"]:

    29

                Result = output

    30

            else:

    31

                hex_value, dec_value = output.split()

    32

                if int(hex_value, 16) == int(dec_value):

    33

                    Result = int(dec_value)

    34

    else:

    35

        Result = res == 0

    36

    37

    SDOAnswered()

    38

    39

def EthercatSDOUpload(pos, index, subindex, var_type):

    40

    global SDOThread

    41

    SDOThread = Thread(target=SDOThreadProc, args=["upload", pos, var_type, index, subindex])

    42

    SDOThread.start()

    43

    44

def EthercatSDODownload(pos, index, subindex, var_type, value):

    45

    global SDOThread

    46

    SDOThread = Thread(target=SDOThreadProc, args=["download", pos, var_type, index, subindex, value])

    47

    SDOThread.start()

    48

    49

def GetResult():

    50

    global Result

    51

    return Result

    52

    53

KMSGPollThread=None

    54

StopKMSGThread=False

    55

def KMSGPollThreadProc():

    56

    """

    57

    Logs Kernel messages starting with EtherCAT

    58

    Uses GLibc wrapper to Linux syscall "klogctl"

    59

    Last 4 KB are polled, and lines compared to last 

    60

    captured line to detect new lines

    61

    """

    62

    global StopKMSGThread

    63

    libc=ctypes.CDLL("libc.so.6")

    64

    klog = libc.klogctl

    65

    klog.argtypes = [ctypes.c_int, ctypes.c_char_p, ctypes.c_int]

    66

    klog.restype = ctypes.c_int

    67

    s=ctypes.create_string_buffer(4*1024)

    68

    last = None

    69

    while not StopKMSGThread:

    70

        l = klog(3,s,len(s)-1)

    71

        log = s.value[:l-1]

    72

        if last :

    73

            log = log.rpartition(last)[2]

    74

        if log : 

    75

            last = log.rpartition('\n')[2]

    76

            for msg in re.findall(r'<\d>\[\s*\d*\.\d*\]\s*(EtherCAT\s*.*)$',

    77

                                  log, re.MULTILINE):

    78

                PLCObject.LogMessage(msg)

    79

        time.sleep(0.5) 

    80

    81

def _runtime_etherlab_init():

    82

    global KMSGPollThread, StopKMSGThread

    83

    StopKMSGThread = False

    84

    KMSGPollThread = Thread(target = KMSGPollThreadProc)

    85

    KMSGPollThread.start()

    86

    87

def _runtime_etherlab_cleanup():

    88

    global KMSGPollThread, StopKMSGThread

    89

    StopKMSGThread = True

    90

    KMSGPollThread = None

    91

    92