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_char_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.c_char_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

        # pass message to the C side recieve_message()

    63

        c_string = ctypes.c_char_p(msg)

    64

        c_string_pointer = ctypes.c_void_p(ctypes.addressof(c_string))

    65

        svghmi_recv_dispatch(len(msg), msg)

    66

    67

        # TODO multiclient : pass client index as well

    68

    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

class HMIWebSocketServerFactory(WebSocketServerFactory):

    94

    protocol = HMIProtocol

    95

    96

svghmi_root = None

    97

svghmi_listener = None

    98

svghmi_send_thread = None

    99

   100

def SendThreadProc():

   101

   global svghmi_session

   102

   size = ctypes.c_uint32()

   103

   ptr = ctypes.c_char_p()

   104

   res = 0

   105

   while svghmi_send_collect(ctypes.byref(size), ctypes.byref(ptr)) == 0 and \

   106

         svghmi_session is not None and \

   107

         svghmi_session.sendMessage(ctypes.string_at(ptr,size)) == 0:

   108

         pass

   109

   110

       # TODO multiclient : dispatch to sessions

   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

   131

    svghmi_root.delEntity("ws")

   132

    svghmi_root = None

   133

    svghmi_listener.stopListening()

   134

    svghmi_listener = None

   135

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

   136

    svghmi_send_thread.join()

   137

    svghmi_send_thread = None

   138