Module ddCommunication.protocols.LCPWirelessProtocol.WLCPWrapper.SerialCommunication.SerialCommunication

Expand source code
from serial.serialwin32 import Serial
import axel
from threading import Lock,Event,Thread
from time import sleep
from queue import Queue


class SerialCommunication:
    """
    Class for raw serial communication
    """

    def __init__(self, COMPort, baud=115200):
        self.COMPort = COMPort
        self.baud_rate = baud
        self.DataReceived = axel.Event()
        self.Started = False
        self.ProbablyDisconnected = axel.Event()
        self.QueueBaseItem = b''
        self.QueueBaseItemLock = Lock()
        self.DataQueue = Queue(0)
        self.DataQueueLock = Lock()
        self.IsRunning = False
        self._stop = Event()

    def AddToQueue(self, data):
        """
        Adds a single data packet to the queue.
        """
        self.DataQueue.put(data)

    def ClearQueue(self):
        """
        Clears the sender queue
        """
        self.DataQueueLock.acquire()
        self.DataQueue = Queue(0)
        self.DataQueueLock.release()

    def SetQueueBaseItem(self, item):
        """
        Sets the base item to send continously to the serial port
        whenever the data queue is empty.
        Is empty by default
        """
        self.QueueBaseItemLock.acquire()
        self.QueueBaseItem = item
        self.QueueBaseItemLock.release()

    def BeginListening(self):
        """
        Begins listening for incoming data
        """
        self.IsRunning = True
        self.listenerThread = Thread(target=self.__BeginListeningThread)
        self.listenerThread.daemon = True
        self.listenerThread.start()

    def __DataReceivedEvent(self, data):
        if len(data) != 0:
            self.DataReceived(Data=data)

    def StopListening(self):
        """
        Stops listening for incoming data
        """
        self._stop.set()
        max_try = 60
        tries = 0
        while self.listenerThread.isAlive() and tries<max_try:
            sleep(1)
            tries += 1
        if self.listenerThread.isAlive():
            raise Exception("Listener thread did not stop")

    def __BeginListeningThread(self):
        with Serial(self.COMPort, self.baud_rate, timeout=0.2) as ser:
            while ser.isOpen() and not self._stop.isSet():
                mes = ser.read_all()

                if len(mes) > 0:
                    timeSinceLastPacket = 0

                self.__DataReceivedEvent(mes)

                while not self.DataQueue.empty() and not self._stop.isSet():
                    self.DataQueueLock.acquire()
                    data = self.DataQueue.get(False)
                    self.DataQueueLock.release()
                    ser.write(data)

                sleep(0.2)
                self.QueueBaseItemLock.acquire()

                if self.QueueBaseItem != b'':
                    ser.write(self.QueueBaseItem)

                self.QueueBaseItemLock.release()

            ser.close()

Classes

class SerialCommunication (COMPort, baud=115200)

Class for raw serial communication

Expand source code
class SerialCommunication:
    """
    Class for raw serial communication
    """

    def __init__(self, COMPort, baud=115200):
        self.COMPort = COMPort
        self.baud_rate = baud
        self.DataReceived = axel.Event()
        self.Started = False
        self.ProbablyDisconnected = axel.Event()
        self.QueueBaseItem = b''
        self.QueueBaseItemLock = Lock()
        self.DataQueue = Queue(0)
        self.DataQueueLock = Lock()
        self.IsRunning = False
        self._stop = Event()

    def AddToQueue(self, data):
        """
        Adds a single data packet to the queue.
        """
        self.DataQueue.put(data)

    def ClearQueue(self):
        """
        Clears the sender queue
        """
        self.DataQueueLock.acquire()
        self.DataQueue = Queue(0)
        self.DataQueueLock.release()

    def SetQueueBaseItem(self, item):
        """
        Sets the base item to send continously to the serial port
        whenever the data queue is empty.
        Is empty by default
        """
        self.QueueBaseItemLock.acquire()
        self.QueueBaseItem = item
        self.QueueBaseItemLock.release()

    def BeginListening(self):
        """
        Begins listening for incoming data
        """
        self.IsRunning = True
        self.listenerThread = Thread(target=self.__BeginListeningThread)
        self.listenerThread.daemon = True
        self.listenerThread.start()

    def __DataReceivedEvent(self, data):
        if len(data) != 0:
            self.DataReceived(Data=data)

    def StopListening(self):
        """
        Stops listening for incoming data
        """
        self._stop.set()
        max_try = 60
        tries = 0
        while self.listenerThread.isAlive() and tries<max_try:
            sleep(1)
            tries += 1
        if self.listenerThread.isAlive():
            raise Exception("Listener thread did not stop")

    def __BeginListeningThread(self):
        with Serial(self.COMPort, self.baud_rate, timeout=0.2) as ser:
            while ser.isOpen() and not self._stop.isSet():
                mes = ser.read_all()

                if len(mes) > 0:
                    timeSinceLastPacket = 0

                self.__DataReceivedEvent(mes)

                while not self.DataQueue.empty() and not self._stop.isSet():
                    self.DataQueueLock.acquire()
                    data = self.DataQueue.get(False)
                    self.DataQueueLock.release()
                    ser.write(data)

                sleep(0.2)
                self.QueueBaseItemLock.acquire()

                if self.QueueBaseItem != b'':
                    ser.write(self.QueueBaseItem)

                self.QueueBaseItemLock.release()

            ser.close()

Methods

def AddToQueue(self, data)

Adds a single data packet to the queue.

Expand source code
def AddToQueue(self, data):
    """
    Adds a single data packet to the queue.
    """
    self.DataQueue.put(data)
def BeginListening(self)

Begins listening for incoming data

Expand source code
def BeginListening(self):
    """
    Begins listening for incoming data
    """
    self.IsRunning = True
    self.listenerThread = Thread(target=self.__BeginListeningThread)
    self.listenerThread.daemon = True
    self.listenerThread.start()
def ClearQueue(self)

Clears the sender queue

Expand source code
def ClearQueue(self):
    """
    Clears the sender queue
    """
    self.DataQueueLock.acquire()
    self.DataQueue = Queue(0)
    self.DataQueueLock.release()
def SetQueueBaseItem(self, item)

Sets the base item to send continously to the serial port whenever the data queue is empty. Is empty by default

Expand source code
def SetQueueBaseItem(self, item):
    """
    Sets the base item to send continously to the serial port
    whenever the data queue is empty.
    Is empty by default
    """
    self.QueueBaseItemLock.acquire()
    self.QueueBaseItem = item
    self.QueueBaseItemLock.release()
def StopListening(self)

Stops listening for incoming data

Expand source code
def StopListening(self):
    """
    Stops listening for incoming data
    """
    self._stop.set()
    max_try = 60
    tries = 0
    while self.listenerThread.isAlive() and tries<max_try:
        sleep(1)
        tries += 1
    if self.listenerThread.isAlive():
        raise Exception("Listener thread did not stop")