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

    11

from twisted.web.server import Site

    12

from twisted.web.resource import Resource

    13

from twisted.internet import reactor

    14

from twisted.web.static import File

    15

    16

from autobahn.twisted.websocket import WebSocketServerFactory, WebSocketServerProtocol

    17

from autobahn.websocket.protocol import WebSocketProtocol

    18

from autobahn.twisted.resource import  WebSocketResource

    19

    20

# TODO multiclient :

    21

# session list lock

    22

# svghmi_sessions = []

    23

    24

svghmi_session = None

    25

    26

svghmi_send_collect = PLCBinary.svghmi_send_collect

    27

svghmi_send_collect.restype = ctypes.c_int # error or 0

    28

svghmi_send_collect.argtypes = [

    29

    ctypes.POINTER(ctypes.c_uint32),  # size

    30

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

    31

# TODO multiclient : switch to arrays

    32

    33

svghmi_recv_dispatch = PLCBinary.svghmi_recv_dispatch

    34

svghmi_recv_dispatch.restype = ctypes.c_int # error or 0

    35

svghmi_recv_dispatch.argtypes = [

    36

    ctypes.c_uint32,  # size

    37

    ctypes.c_char_p]  # data ptr

    38

# TODO multiclient : switch to arrays

    39

    40

class HMISession(object):

    41

    def __init__(self, protocol_instance):

    42

        global svghmi_session

    43

    44

        # Single client :

    45

        # Creating a new HMISession closes pre-existing HMISession

    46

        if svghmi_session is not None:

    47

            svghmi_session.close()

    48

        svghmi_session = self

    49

        self.protocol_instance = protocol_instance

    50

    51

        # TODO multiclient :

    52

        # svghmi_sessions.append(self)

    53

        # get a unique bit index amont other svghmi_sessions,

    54

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

    55

    56

    def close(self):

    57

        global svghmi_session

    58

        if svghmi_session == self:

    59

            svghmi_session = None

    60

        self.protocol_instance.sendClose(WebSocketProtocol.CLOSE_STATUS_CODE_NORMAL)

    61

    62

    def onMessage(self, msg):

    63

        # pass message to the C side recieve_message()

    64

        svghmi_recv_dispatch(len(msg), msg)

    65

    66

        # TODO multiclient : pass client index as well

    67

    68

    69

    def sendMessage(self, msg):

    70

        self.protocol_instance.sendMessage(msg, True)

    71

        return 0

    72

    73

class HMIProtocol(WebSocketServerProtocol):

    74

    75

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

    76

        self._hmi_session = None

    77

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

    78

    79

    def onOpen(self):

    80

        assert(self._hmi_session is None)

    81

        self._hmi_session = HMISession(self)

    82

    83

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

    84

        self._hmi_session = None

    85

    86

    def onMessage(self, msg, isBinary):

    87

        assert(self._hmi_session is not None)

    88

        self._hmi_session.onMessage(msg)

    89

    90

class HMIWebSocketServerFactory(WebSocketServerFactory):

    91

    protocol = HMIProtocol

    92

    93

svghmi_root = None

    94

svghmi_listener = None

    95

svghmi_send_thread = None

    96

    97

def SendThreadProc():

   115

   116

   117

   118

   119

# Called by PLCObject at start

   120

def _runtime_svghmi0_start():

   121

    global svghmi_listener, svghmi_root, svghmi_send_thread

   122

   123

    svghmi_root = Resource()

   124

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

   125

   126

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

   127

   128

    # start a thread that call the C part of SVGHMI

   129

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

   130

    svghmi_send_thread.start()

   131

   132

   133

# Called by PLCObject at stop

   134

def _runtime_svghmi0_stop():

   135

    global svghmi_listener, svghmi_root, svghmi_send_thread, svghmi_session

   136

    if svghmi_session is not None:

   137

        svghmi_session.close()

   138

    svghmi_root.delEntity("ws")

   139

    svghmi_root = None

   140

    svghmi_listener.stopListening()

   141

    svghmi_listener = None

   142

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

   143

    svghmi_send_thread.join()

   144

    svghmi_send_thread = None

   145