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

        svghmi_recv_dispatch(len(msg), msg)

    64

    65

        # TODO multiclient : pass client index as well

    66

    67

    68

    def sendMessage(self, msg):

    69

        self.sendMessage(msg, True)

    70

    71

class HMIProtocol(WebSocketServerProtocol):

    72

    73

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

    74

        self._hmi_session = None

    75

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

    76

    77

    def onOpen(self):

    78

        self._hmi_session = HMISession(self)

    79

        print "open"

    80

    81

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

    82

        del self._hmi_session

    83

        self._hmi_session = None

    84

        print "close"

    85

    86

    def onMessage(self, msg, isBinary):

    87

        self._hmi_session.onMessage(msg)

    88

        print msg

    89

        #self.sendMessage(msg, binary)

    90

    91

class HMIWebSocketServerFactory(WebSocketServerFactory):

    92

    protocol = HMIProtocol

    93

    94

svghmi_root = None

    95

svghmi_listener = None

    96

svghmi_send_thread = None

    97

    98

def SendThreadProc():

    99

   global svghmi_session

   100

   size = ctypes.c_uint32()

   101

   ptr = ctypes.c_char_p()

   102

   res = 0

   103

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

   104

         svghmi_session is not None and \

   105

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

   106

         pass

   107

   108

       # TODO multiclient : dispatch to sessions

   109

   110

   111

   112

# Called by PLCObject at start

   113

def _runtime_svghmi0_start():

   114

    global svghmi_listener, svghmi_root, svghmi_send_thread

   115

   116

    svghmi_root = Resource()

   117

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

   118

   119

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

   120

   121

    # start a thread that call the C part of SVGHMI

   122

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

   123

    svghmi_send_thread.start()

   124

   125

   126

# Called by PLCObject at stop

   127

def _runtime_svghmi0_stop():

   128

    global svghmi_listener, svghmi_root, svghmi_send_thread

   129

    svghmi_root.delEntity("ws")

   130

    svghmi_root = None

   131

    svghmi_listener.stopListening()

   132

    svghmi_listener = None

   133

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

   134

    svghmi_send_thread.join()

   135

    svghmi_send_thread = None

   136