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, interval, callback):

    82

        self._callback = callback

    83

        self.lock = RLock()

    84

        self.initial_timeout = initial_timeout

    85

        self.interval = interval

    86

        self.callback = callback

    87

        with self.lock:

    88

            self._start()

    89

    90

    def _start(self, rearm=False):

    91

        duration = self.interval if rearm else self.initial_timeout

    92

        if duration:

    93

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

    94

            self.timer.start()

    95

        else:

    96

            self.timer = None

    97

    98

    def _stop(self):

    99

        if self.timer is not None:

   100

            self.timer.cancel()

   101

            self.timer = None

   102

   103

    def cancel(self):

   104

        with self.lock:

   105

            self._stop()

   106

   107

    def feed(self, rearm=True):

   108

        with self.lock:

   109

            self._stop()

   110

            self._start(rearm)

   111

   112

    def trigger(self):

   113

        self._callback()

   114

        # wait for initial timeout on re-start

   115

        self.feed(rearm=False)

   116

   117

class HMIProtocol(WebSocketServerProtocol):

   118

   119

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

   120

        self._hmi_session = None

   121

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

   122

   123

    def onOpen(self):

   124

        assert(self._hmi_session is None)

   125

        self._hmi_session = HMISession(self)

   126

   127

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

   128

        self._hmi_session = None

   129

   130

    def onMessage(self, msg, isBinary):

   131

        assert(self._hmi_session is not None)

   132

   133

        result = self._hmi_session.onMessage(msg)

   134

        if result == 1 :  # was heartbeat

   135

            if svghmi_watchdog is not None:

   136

                svghmi_watchdog.feed()

   137

   138

class HMIWebSocketServerFactory(WebSocketServerFactory):

   139

    protocol = HMIProtocol

   140

   141

svghmi_root = None

   142

svghmi_listener = None

   143

svghmi_send_thread = None

   144

   145

def SendThreadProc():

   146

    global svghmi_session

   147

    size = ctypes.c_uint32()

   148

    ptr = ctypes.c_void_p()

   149

    res = 0

   150

    while True:

   151

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

   152

        if res == 0:

   153

            # TODO multiclient : dispatch to sessions

   154

            if svghmi_session is not None:

   155

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

   156

        elif res == errno.ENODATA:

   157

            # this happens when there is no data after wakeup

   158

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

   159

            pass 

   160

        else:

   161

            # this happens when finishing

   162

            break

   163

   164

   165

def watchdog_trigger():

   166

    print("SVGHMI watchdog trigger")

   167

   168

   169

# Called by PLCObject at start

   170

def _runtime_00_svghmi_start():

   171

    global svghmi_listener, svghmi_root, svghmi_send_thread

   172

   173

    svghmi_root = Resource()

   174

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

   175

   176

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

   177

   178

    # start a thread that call the C part of SVGHMI

   179

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

   180

    svghmi_send_thread.start()

   181

   182

   183

# Called by PLCObject at stop

   184

def _runtime_00_svghmi_stop():

   185

    global svghmi_listener, svghmi_root, svghmi_send_thread, svghmi_session

   186

   187

    if svghmi_session is not None:

   188

        svghmi_session.close()

   189

    svghmi_root.delEntity("ws")

   190

    svghmi_root = None

   191

    svghmi_listener.stopListening()

   192

    svghmi_listener = None

   193

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

   194

    svghmi_send_thread.join()

   195

    svghmi_send_thread = None

   196

   197

   198

class NoCacheFile(File):

   199

    def render_GET(self, request):

   200

        request.setHeader(b"Cache-Control", b"no-cache, no-store")

   201

        return File.render_GET(self, request)

   202

    render_HEAD = render_GET

   203

   204