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

    27

svghmi_watchdog = None

    28

    29

svghmi_send_collect = PLCBinary.svghmi_send_collect

    30

svghmi_send_collect.restype = ctypes.c_int # error or 0

    31

svghmi_send_collect.argtypes = [

    33

    ctypes.POINTER(ctypes.c_uint32),  # size

    34

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

    35

    36

svghmi_recv_dispatch = PLCBinary.svghmi_recv_dispatch

    37

svghmi_recv_dispatch.restype = ctypes.c_int # error or 0

    38

svghmi_recv_dispatch.argtypes = [

    40

    ctypes.c_uint32,  # size

    41

    ctypes.c_char_p]  # data ptr

   120

   121

class HMISession(object):

   122

    def __init__(self, protocol_instance):

   123

        self.protocol_instance = protocol_instance

   137

   138

    def close(self):

   139

        self.protocol_instance.sendClose(WebSocketProtocol.CLOSE_STATUS_CODE_NORMAL)

   140

   141

    def onMessage(self, msg):

   142

        # pass message to the C side recieve_message()

   144

   145

    def sendMessage(self, msg):

   146

        self.protocol_instance.sendMessage(msg, True)

   147

        return 0

   148

   149

class Watchdog(object):

   150

    def __init__(self, initial_timeout, interval, callback):

   151

        self._callback = callback

   152

        self.lock = RLock()

   153

        self.initial_timeout = initial_timeout

   154

        self.interval = interval

   155

        self.callback = callback

   156

        with self.lock:

   157

            self._start()

   158

   159

    def _start(self, rearm=False):

   160

        duration = self.interval if rearm else self.initial_timeout

   161

        if duration:

   162

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

   163

            self.timer.start()

   164

        else:

   165

            self.timer = None

   166

   167

    def _stop(self):

   168

        if self.timer is not None:

   169

            self.timer.cancel()

   170

            self.timer = None

   171

   172

    def cancel(self):

   173

        with self.lock:

   174

            self._stop()

   175

   176

    def feed(self, rearm=True):

   177

        with self.lock:

   178

            self._stop()

   179

            self._start(rearm)

   180

   181

    def trigger(self):

   182

        self._callback()

   186

   187

class HMIProtocol(WebSocketServerProtocol):

   188

   189

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

   190

        self._hmi_session = None

   192

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

   193

   194

    def onConnect(self, request):

   195

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

   196

        return WebSocketServerProtocol.onConnect(self, request)

   197

   198

    def onOpen(self):

   200

        assert(self._hmi_session is None)

   201

        self._hmi_session = HMISession(self)

   203

   204

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

   207

        self._hmi_session = None

   208

   209

    def onMessage(self, msg, isBinary):

   211

        assert(self._hmi_session is not None)

   212

   213

        result = self._hmi_session.onMessage(msg)

   215

            if svghmi_watchdog is not None:

   216

                svghmi_watchdog.feed()

   217

   218

class HMIWebSocketServerFactory(WebSocketServerFactory):

   219

    protocol = HMIProtocol

   220

   221

svghmi_servers = {}

   222

svghmi_send_thread = None

   223

   224

def SendThreadProc():

   226

    size = ctypes.c_uint32()

   227

    ptr = ctypes.c_void_p()

   228

    res = 0

   247

   248

def AddPathToSVGHMIServers(path, factory):

   249

    for k,v in svghmi_servers.iteritems():

   250

        svghmi_root, svghmi_listener, path_list = v

   251

        svghmi_root.putChild(path, factory())

   252

   253

# Called by PLCObject at start

   254

def _runtime_00_svghmi_start():

   255

    global svghmi_send_thread

   256

   257

    # start a thread that call the C part of SVGHMI

   258

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

   259

    svghmi_send_thread.start()

   260

   261

   262

# Called by PLCObject at stop

   263

def _runtime_00_svghmi_stop():

   264

    global svghmi_send_thread, svghmi_session

   265

   268

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

   269

    svghmi_send_thread.join()

   270

    svghmi_send_thread = None

   271

   272

   273

class NoCacheFile(File):

   274

    def render_GET(self, request):

   275

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

   276

        return File.render_GET(self, request)

   277

    render_HEAD = render_GET

   278

   279