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():

    98

   global svghmi_session

    99

   size = ctypes.c_uint32()

   100

   ptr = ctypes.c_void_p()

   101

   res = 0

   102

   while True:

   103

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

   104

       if res == 0:

   105

           # TODO multiclient : dispatch to sessions

   106

           if svghmi_session is not None:

   107

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

   108

       elif res not in [errno.EAGAIN, errno.ENODATA]:

   109

           break

   110

   111

   112

   113

   114

# Called by PLCObject at start

   115

def _runtime_svghmi0_start():

   116

    global svghmi_listener, svghmi_root, svghmi_send_thread

   117

   118

    svghmi_root = Resource()

   119

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

   120

   121

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

   122

   123

    # start a thread that call the C part of SVGHMI

   124

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

   125

    svghmi_send_thread.start()

   126

   127

   128

# Called by PLCObject at stop

   129

def _runtime_svghmi0_stop():

   130

    global svghmi_listener, svghmi_root, svghmi_send_thread, svghmi_session

   131

    if svghmi_session is not None:

   132

        svghmi_session.close()

   133

    svghmi_root.delEntity("ws")

   134

    svghmi_root = None

   135

    svghmi_listener.stopListening()

   136

    svghmi_listener = None

   137

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

   138

    svghmi_send_thread.join()

   139

    svghmi_send_thread = None

   140