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

    10

from twisted.web.server import Site

    11

from twisted.web.resource import Resource

    12

from twisted.internet import reactor

    13

from twisted.web.static import File

    14

    15

from autobahn.twisted.websocket import WebSocketServerFactory, WebSocketServerProtocol

    16

from autobahn.twisted.resource import  WebSocketResource

    17

    18

# TODO multiclient :

    19

# session list lock

    20

# svghmi_sessions = []

    21

    22

svghmi_session = None

    23

    24

svghmi_send_collect = PLCBinary.svghmi_send_collect

    25

svghmi_send_collect.restype = ctypes.c_int # error or 0

    26

svghmi_send_collect.argtypes = [

    27

    ctypes.POINTER(ctypes.c_uint32),  # size

    28

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

    29

# TODO multiclient : switch to arrays

    30

    31

svghmi_recv_dispatch = PLCBinary.svghmi_recv_dispatch

    32

svghmi_recv_dispatch.restype = ctypes.c_int # error or 0

    33

svghmi_recv_dispatch.argtypes = [

    34

    ctypes.c_uint32,                  # size

    35

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

    36

# TODO multiclient : switch to arrays

    37

    38

class HMISession(object):

    39

    def __init__(self, protocol_instance):

    40

        global svghmi_session

    41

    42

        # TODO: kill existing session for robustness

    43

        assert(svghmi_session is None)

    44

    45

        svghmi_session = self

    46

        self.protocol_instance = protocol_instance

    47

    48

        # TODO multiclient :

    49

        # svghmi_sessions.append(self)

    50

        # get a unique bit index amont other svghmi_sessions,

    51

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

    52

    53

    def __del__(self):

    54

        global svghmi_session

    55

        assert(svghmi_session)

    56

        svghmi_session = None

    57

    58

        # TODO multiclient :

    59

        # svghmi_sessions.remove(self)

    60

    61

    def onMessage(self, msg):

    62

        # TODO :  pass it to the C side recieve_message()

    63

        #    update HMITree

    64

        #        - values

    65

        #        - refresh rates / subsriptions

    66

    67

        # TODO multiclient : pass client index as well

    68

        pass

    69

    70

    def sendMessage(self, msg):

    71

        self.sendMessage(msg, True)

    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

        self._hmi_session = HMISession(self)

    81

        print "open"

    82

    83

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

    84

        del self._hmi_session

    85

        self._hmi_session = None

    86

        print "close"

    87

    88

    def onMessage(self, msg, isBinary):

    89

        self._hmi_session.onMessage(msg)

    90

        print msg

    91

        #self.sendMessage(msg, binary)

    92

    93

svghmi_root = None

    94

svghmi_listener = None

    95

svghmi_send_thread = None

    96

   109

   110

# Called by PLCObject at start

   111

def _runtime_svghmi0_start():

   112

    global svghmi_listener, svghmi_root, svghmi_send_thread

   113

   114

    svghmi_root = Resource()

   115

   116

    wsfactory = WebSocketServerFactory()

   117

    wsfactory.protocol = HMIProtocol

   118

   119

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

   120

   121

    sitefactory = Site(svghmi_root)

   122

   123

    svghmi_listener = reactor.listenTCP(8008, sitefactory)

   124

   125

    # start a thread that call the C part of SVGHMI

   126

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

   127

    svghmi_send_thread.start()

   128

   129

   130

# Called by PLCObject at stop

   131

def _runtime_svghmi0_stop():

   132

    global svghmi_listener, svghmi_root, svghmi_send_thread

   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