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 onConnect(self, request):

   124

        self.has_watchdog = request.params.get("mode", [None])[0] == "watchdog"

   125

        return WebSocketServerProtocol.onConnect(self, request)

   126

   127

    def onOpen(self):

   128

        assert(self._hmi_session is None)

   129

        self._hmi_session = HMISession(self)

   130

   131

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

   132

        self._hmi_session = None

   133

   134

    def onMessage(self, msg, isBinary):

   135

        assert(self._hmi_session is not None)

   136

   137

        result = self._hmi_session.onMessage(msg)

   138

        if result == 1 :  # was heartbeat

   139

            if svghmi_watchdog is not None:

   140

                svghmi_watchdog.feed()

   141

   142

class HMIWebSocketServerFactory(WebSocketServerFactory):

   143

    protocol = HMIProtocol

   144

   146

svghmi_send_thread = None

   147

   148

def SendThreadProc():

   149

    global svghmi_session

   150

    size = ctypes.c_uint32()

   151

    ptr = ctypes.c_void_p()

   152

    res = 0

   153

    while True:

   154

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

   155

        if res == 0:

   156

            # TODO multiclient : dispatch to sessions

   157

            if svghmi_session is not None:

   158

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

   159

        elif res == errno.ENODATA:

   160

            # this happens when there is no data after wakeup

   161

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

   162

            pass 

   163

        else:

   164

            # this happens when finishing

   165

            break

   166

   171

   172

# Called by PLCObject at start

   173

def _runtime_00_svghmi_start():

   175

   176

    # start a thread that call the C part of SVGHMI

   177

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

   178

    svghmi_send_thread.start()

   179

   180

   181

# Called by PLCObject at stop

   182

def _runtime_00_svghmi_stop():

   184

   185

    if svghmi_session is not None:

   186

        svghmi_session.close()

   187

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

   188

    svghmi_send_thread.join()

   189

    svghmi_send_thread = None

   190

   191

   192

class NoCacheFile(File):

   193

    def render_GET(self, request):

   194

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

   195

        return File.render_GET(self, request)

   196

    render_HEAD = render_GET

   197

   198