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

    11

    12

from twisted.web.server import Site

    13

from twisted.web.resource import Resource

    14

from twisted.internet import reactor

    15

from twisted.web.static import File

    16

    17

from autobahn.twisted.websocket import WebSocketServerFactory, WebSocketServerProtocol

    18

from autobahn.websocket.protocol import WebSocketProtocol

    19

from autobahn.twisted.resource import  WebSocketResource

    20

    21

# TODO multiclient :

    22

# session list lock

    23

# svghmi_sessions = []

    25

    26

svghmi_session = None

    28

    29

svghmi_send_collect = PLCBinary.svghmi_send_collect

    30

svghmi_send_collect.restype = ctypes.c_int # error or 0

    31

svghmi_send_collect.argtypes = [

    32

    ctypes.POINTER(ctypes.c_uint32),  # size

    33

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

    34

# TODO multiclient : switch to arrays

    35

    36

svghmi_recv_dispatch = PLCBinary.svghmi_recv_dispatch

    37

svghmi_recv_dispatch.restype = ctypes.c_int # error or 0

    38

svghmi_recv_dispatch.argtypes = [

    39

    ctypes.c_uint32,  # size

    40

    ctypes.c_char_p]  # data ptr

    41

# TODO multiclient : switch to arrays

    42

    43

class HMISession(object):

    44

    def __init__(self, protocol_instance):

    45

        global svghmi_session

    46

    47

        # Single client :

    48

        # Creating a new HMISession closes pre-existing HMISession

    49

        if svghmi_session is not None:

    50

            svghmi_session.close()

    51

        svghmi_session = self

    52

        self.protocol_instance = protocol_instance

    53

    54

        # TODO multiclient :

    55

        # svghmi_sessions.append(self)

    56

        # get a unique bit index amont other svghmi_sessions,

    57

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

    58

    59

    def close(self):

    60

        global svghmi_session

    61

        if svghmi_session == self:

    62

            svghmi_session = None

    63

        self.protocol_instance.sendClose(WebSocketProtocol.CLOSE_STATUS_CODE_NORMAL)

    64

    65

    def onMessage(self, msg):

    66

        # pass message to the C side recieve_message()

    68

    69

        # TODO multiclient : pass client index as well

    70

    71

    def sendMessage(self, msg):

    72

        self.protocol_instance.sendMessage(msg, True)

    73

        return 0

    74

   106

class HMIProtocol(WebSocketServerProtocol):

   107

   108

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

   109

        self._hmi_session = None

   110

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

   111

   112

    def onOpen(self):

   113

        assert(self._hmi_session is None)

   114

        self._hmi_session = HMISession(self)

   115

   116

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

   117

        self._hmi_session = None

   118

   119

    def onMessage(self, msg, isBinary):

   120

        assert(self._hmi_session is not None)

   126

   127

class HMIWebSocketServerFactory(WebSocketServerFactory):

   128

    protocol = HMIProtocol

   129

   130

svghmi_root = None

   131

svghmi_listener = None

   132

svghmi_send_thread = None

   133

   134

def SendThreadProc():

   135

    global svghmi_session

   136

    size = ctypes.c_uint32()

   137

    ptr = ctypes.c_void_p()

   138

    res = 0

   139

    while True:

   140

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

   141

        if res == 0:

   142

            # TODO multiclient : dispatch to sessions

   143

            if svghmi_session is not None:

   144

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

   145

        elif res == errno.ENODATA:

   146

            # this happens when there is no data after wakeup

   147

            # because of hmi data refresh period longer than PLC common ticktime

   148

            pass 

   149

        else:

   150

            # this happens when finishing

   151

            break

   152

   153

   157

   158

# Called by PLCObject at start

   159

def _runtime_svghmi0_start():

   161

   162

    svghmi_root = Resource()

   163

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

   164

   165

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

   166

   167

    # start a thread that call the C part of SVGHMI

   168

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

   169

    svghmi_send_thread.start()

   170

   172

   173

# Called by PLCObject at stop

   174

def _runtime_svghmi0_stop():

   181

    if svghmi_session is not None:

   182

        svghmi_session.close()

   183

    svghmi_root.delEntity("ws")

   184

    svghmi_root = None

   185

    svghmi_listener.stopListening()

   186

    svghmi_listener = None

   187

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

   188

    svghmi_send_thread.join()

   189

    svghmi_send_thread = None

   190