1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz

     5

# Copyright (C) 2019: Edouard TISSERANT

     6

# See COPYING file for copyrights details.

     7

     8

from __future__ import absolute_import

     9

import errno

    10

from threading import RLock, Timer

    11

    12

try:

    13

    from runtime.spawn_subprocess import Popen

    14

except ImportError:

    15

    from subprocess import Popen

    16

    17

from twisted.web.server import Site

    18

from twisted.web.resource import Resource

    19

from twisted.internet import reactor

    20

from twisted.web.static import File

    21

    22

from autobahn.twisted.websocket import WebSocketServerFactory, WebSocketServerProtocol

    23

from autobahn.websocket.protocol import WebSocketProtocol

    24

from autobahn.twisted.resource import  WebSocketResource

    25

    26

# TODO multiclient :

    27

# session list lock

    28

# svghmi_sessions = []

    29

# svghmi_watchdogs = []

    30

    31

svghmi_session = None

    32

svghmi_watchdog = None

    33

    34

svghmi_send_collect = PLCBinary.svghmi_send_collect

    35

svghmi_send_collect.restype = ctypes.c_int # error or 0

    36

svghmi_send_collect.argtypes = [

    37

    ctypes.POINTER(ctypes.c_uint32),  # size

    38

    ctypes.POINTER(ctypes.c_void_p)]  # data ptr

    39

# TODO multiclient : switch to arrays

    40

    41

svghmi_recv_dispatch = PLCBinary.svghmi_recv_dispatch

    42

svghmi_recv_dispatch.restype = ctypes.c_int # error or 0

    43

svghmi_recv_dispatch.argtypes = [

    44

    ctypes.c_uint32,  # size

    45

    ctypes.c_char_p]  # data ptr

    46

# TODO multiclient : switch to arrays

    47

    48

class HMISession(object):

    49

    def __init__(self, protocol_instance):

    50

        global svghmi_session

    51

    52

        # Single client :

    53

        # Creating a new HMISession closes pre-existing HMISession

    54

        if svghmi_session is not None:

    55

            svghmi_session.close()

    56

        svghmi_session = self

    57

        self.protocol_instance = protocol_instance

    58

    59

        # TODO multiclient :

    60

        # svghmi_sessions.append(self)

    61

        # get a unique bit index amont other svghmi_sessions,

    62

        # so that we can match flags passed by C->python callback

    63

    64

    def close(self):

    65

        global svghmi_session

    66

        if svghmi_session == self:

    67

            svghmi_session = None

    68

        self.protocol_instance.sendClose(WebSocketProtocol.CLOSE_STATUS_CODE_NORMAL)

    69

    70

    def onMessage(self, msg):

    71

        # pass message to the C side recieve_message()

    72

        return svghmi_recv_dispatch(len(msg), msg)

    73

    74

        # TODO multiclient : pass client index as well

    75

    76

    def sendMessage(self, msg):

    77

        self.protocol_instance.sendMessage(msg, True)

    78

        return 0

    79

    80

class Watchdog(object):

    81

    def __init__(self, initial_timeout, callback):

    82

        self._callback = callback

    83

        self.lock = RLock()

    84

        self.initial_timeout = initial_timeout

    85

        self.callback = callback

    86

        with self.lock:

    87

            self._start()

    88

    89

    def _start(self):

    90

        self.timer = Timer(self.initial_timeout, self.trigger)

    91

        self.timer.start()

    92

    93

    def _stop(self):

    94

        if self.timer is not None:

    95

            self.timer.cancel()

    96

            self.timer = None

    97

    98

    def cancel(self):

    99

        with self.lock:

   100

            self._stop()

   101

   102

    def feed(self):

   103

        with self.lock:

   104

            self._stop()

   105

            self._start()

   106

   107

    def trigger(self):

   108

        self._callback()

   109

        self.feed()

   110

   111

class HMIProtocol(WebSocketServerProtocol):

   112

   113

    def __init__(self, *args, **kwargs):

   114

        self._hmi_session = None

   115

        WebSocketServerProtocol.__init__(self, *args, **kwargs)

   116

   117

    def onOpen(self):

   118

        assert(self._hmi_session is None)

   119

        self._hmi_session = HMISession(self)

   120

   121

    def onClose(self, wasClean, code, reason):

   122

        self._hmi_session = None

   123

   124

    def onMessage(self, msg, isBinary):

   125

        assert(self._hmi_session is not None)

   126

   127

        result = self._hmi_session.onMessage(msg)

   128

        if result == 1 :  # was heartbeat

   129

            if svghmi_watchdog is not None:

   130

                svghmi_watchdog.feed()

   131

   132

class HMIWebSocketServerFactory(WebSocketServerFactory):

   133

    protocol = HMIProtocol

   134

   135

svghmi_root = None

   136

svghmi_listener = None

   137

svghmi_send_thread = None

   138

   139

def SendThreadProc():

   140

    global svghmi_session

   141

    size = ctypes.c_uint32()

   142

    ptr = ctypes.c_void_p()

   143

    res = 0

   144

    while True:

   145

        res=svghmi_send_collect(ctypes.byref(size), ctypes.byref(ptr))

   146

        if res == 0:

   147

            # TODO multiclient : dispatch to sessions

   148

            if svghmi_session is not None:

   149

                svghmi_session.sendMessage(ctypes.string_at(ptr.value,size.value))

   150

        elif res == errno.ENODATA:

   151

            # this happens when there is no data after wakeup

   152

            # because of hmi data refresh period longer than PLC common ticktime

   153

            pass 

   154

        else:

   155

            # this happens when finishing

   156

            break

   157

   158

   159

def watchdog_trigger():

   160

    print("SVGHMI watchdog trigger")

   161

   162

   163

# Called by PLCObject at start

   164

def _runtime_svghmi0_start():

   165

    global svghmi_listener, svghmi_root, svghmi_send_thread, svghmi_watchdog

   166

   167

    svghmi_root = Resource()

   168

    svghmi_root.putChild("ws", WebSocketResource(HMIWebSocketServerFactory()))

   169

   170

    svghmi_listener = reactor.listenTCP(8008, Site(svghmi_root))

   171

   172

    # start a thread that call the C part of SVGHMI

   173

    svghmi_send_thread = Thread(target=SendThreadProc, name="SVGHMI Send")

   174

    svghmi_send_thread.start()

   175

   176

    svghmi_watchdog = Watchdog(5, watchdog_trigger)

   177

   178

# Called by PLCObject at stop

   179

def _runtime_svghmi0_stop():

   180

    global svghmi_listener, svghmi_root, svghmi_send_thread, svghmi_session, svghmi_watchdog

   181

   182

    if svghmi_watchdog is not None:

   183

        svghmi_watchdog.cancel()

   184

        svghmi_watchdog = None

   185

   186

    if svghmi_session is not None:

   187

        svghmi_session.close()

   188

    svghmi_root.delEntity("ws")

   189

    svghmi_root = None

   190

    svghmi_listener.stopListening()

   191

    svghmi_listener = None

   192

    # plc cleanup calls svghmi_(locstring)_cleanup and unlocks send thread

   193

    svghmi_send_thread.join()

   194

    svghmi_send_thread = None

   195