From 16ba9c7ef8e52d79f7e13341ef4fa469077157a7 Mon Sep 17 00:00:00 2001 From: "Robin.Mueller" <robin.mueller.m@gmail.com> Date: Tue, 17 Mar 2020 02:11:52 +0100 Subject: [PATCH] little adaptions --- OBSW_TmTcClient.py | 3 +- config/OBSW_Config.py | 5 +- sendreceive/OBSW_CommandSenderReceiver.py | 58 +++++++++---------- .../OBSW_MultipleCommandsSenderReceiver.py | 12 ++-- sendreceive/OBSW_SequentialSenderReceiver.py | 58 +++++++++---------- .../OBSW_SingleCommandSenderReceiver.py | 28 ++++----- tc/OBSW_TcPacket.py | 6 +- test/OBSW_UnitTest.py | 8 +-- 8 files changed, 86 insertions(+), 92 deletions(-) diff --git a/OBSW_TmTcClient.py b/OBSW_TmTcClient.py index 8ed30bd..72cec1f 100644 --- a/OBSW_TmTcClient.py +++ b/OBSW_TmTcClient.py @@ -52,7 +52,6 @@ S. Gaisser, J. Meier, R. Mueller """ import atexit -import time from collections import deque import unittest import logging @@ -160,7 +159,7 @@ def setCommunicationInterface(tmtcPrinter: TmTcPrinterT) -> ComIF_T: :return: CommunicationInterface object """ try: - if g.comIF == 0: + if g.comIF == g.ComIF.Ethernet: communicationInterface = EthernetComIF( tmtcPrinter=tmtcPrinter, tmTimeout=g.tmTimeout, tcTimeoutFactor=g.tcSendTimeoutFactor, sendAddress=g.sendAddress, receiveAddress=g.recAddress) diff --git a/config/OBSW_Config.py b/config/OBSW_Config.py index 6fcab66..b980e55 100644 --- a/config/OBSW_Config.py +++ b/config/OBSW_Config.py @@ -117,9 +117,9 @@ def setGlobals(args): print("Invalid mode argument, setting default mode (1)") modeId = ModeList[1] - if args.comIF == ComIF.Ethernet: + if args.comIF == 0: comIF = ComIF.Ethernet - elif args.comIF == ComIF.Serial: + elif args.comIF == 1: comIF = ComIF.Serial else: print("Invalid Communication Interface, setting serial (1)") @@ -132,7 +132,6 @@ def setGlobals(args): service = args.service recAddress = recAddressToSet sendAddress = sendAddressToSet - comIF = args.comIF modeId = modeId comPort = args.COM printHkData = args.hk diff --git a/sendreceive/OBSW_CommandSenderReceiver.py b/sendreceive/OBSW_CommandSenderReceiver.py index c56d115..0a20337 100644 --- a/sendreceive/OBSW_CommandSenderReceiver.py +++ b/sendreceive/OBSW_CommandSenderReceiver.py @@ -32,6 +32,11 @@ class CommandSenderReceiver: :param doPrintToFile: Specify whether output is also printed to a file """ self.tmTimeout = tmTimeout + self.pusPacketInfo = [] + self.pusPacket = [] + self.tcSendTimeoutFactor = tcSendTimeoutFactor + self.doPrintToFile = doPrintToFile + self.faultyInput = False if isinstance(comInterface, CommunicationInterface): self._comInterface = comInterface @@ -47,43 +52,38 @@ class CommandSenderReceiver: self._tmListener = tmListener else: raise TypeError("Invalid TM Listener type!") + self._replyReceived = False + self._tmReady = False - self.replyReceived = False - self.tmReady = False - self.pusPacketInfo = [] - self.pusPacket = [] - - self.start_time = 0 - self.elapsed_time = 0 - self.timeoutCounter = 0 - self.tcSendTimeoutFactor = tcSendTimeoutFactor - self.doPrintToFile = doPrintToFile - self.queueEntryIsTelecommand = True + self.__start_time = 0 + self.__elapsed_time = 0 + self.__timeoutCounter = 0 + self.__queueEntryIsTelecommand = True # needed to store last actual tc packet from queue - self.lastTc = bytearray() - self.lastTcInfo = dict() + self.__lastTc = bytearray() + self.__lastTcInfo = dict() # ignore periodic packets for timeout when checking a sequence - self.isPacketToIgnore = False + self.__isPacketToIgnore = False - def checkForFirstReply(self) -> None: + def _checkForFirstReply(self) -> None: """ Checks for replies. If no reply is received, send telecommand again in checkForTimeout() :return: None """ if self._tmListener.replyEvent.is_set(): - self.replyReceived = True + self._replyReceived = True self._tmListener.replyEvent.clear() else: if len(self.pusPacket) == 0: print("Command Sender Receiver: No command has been sent yet") else: - self.checkForTimeout() + self._checkForTimeout() # Check for special queue entries. - def checkQueueEntry(self, tcQueueEntry): + def _checkQueueEntry(self, tcQueueEntry): (self.pusPacketInfo, self.pusPacket) = tcQueueEntry - self.queueEntryIsTelecommand = False + self.__queueEntryIsTelecommand = False if self.pusPacketInfo == "wait": waitTime = self.pusPacket self.tmTimeout = self.tmTimeout + waitTime @@ -98,25 +98,25 @@ class CommandSenderReceiver: elif self.pusPacketInfo == "timeout": self.tmTimeout = self.pusPacket else: - self.queueEntryIsTelecommand = True - self.lastTc, self.lastTcInfo = (self.pusPacket, self.pusPacketInfo) + self.__queueEntryIsTelecommand = True + self.__lastTc, self.__lastTcInfo = (self.pusPacket, self.pusPacketInfo) - def checkForTimeout(self): + def _checkForTimeout(self): """ Checks whether a timeout after sending a telecommand has occured and sends telecommand again. If resending reached certain counter, exit the program. :return: """ - if self.timeoutCounter == 5: + if self.__timeoutCounter == 5: print("Command Sender Receiver: No response from command !") exit() - if self.start_time != 0: - self.elapsed_time = time.time() - self.start_time - if self.elapsed_time > self.tmTimeout * self.tcSendTimeoutFactor: + if self.__start_time != 0: + self.__elapsed_time = time.time() - self.__start_time + if self.__elapsed_time > self.tmTimeout * self.tcSendTimeoutFactor: print("Command Sender Receiver: Timeout, sending TC again !") - self._comInterface.sendTelecommand(self.lastTc, self.lastTcInfo) - self.timeoutCounter = self.timeoutCounter + 1 - self.start_time = time.time() + self._comInterface.sendTelecommand(self.__lastTc, self.__lastTcInfo) + self.__timeoutCounter = self.__timeoutCounter + 1 + self.__start_time = time.time() time.sleep(0.5) diff --git a/sendreceive/OBSW_MultipleCommandsSenderReceiver.py b/sendreceive/OBSW_MultipleCommandsSenderReceiver.py index 4c5b4d1..5041320 100644 --- a/sendreceive/OBSW_MultipleCommandsSenderReceiver.py +++ b/sendreceive/OBSW_MultipleCommandsSenderReceiver.py @@ -67,19 +67,19 @@ class MultipleCommandSenderReceiver(SequentialCommandSenderReceiver): return self.tcInfoQueue, self.tmInfoQueue def handleTcResending(self): - while not self.allRepliesReceived: - if self.tcQueue.empty(): + while not self.__allRepliesReceived: + if self._tcQueue.empty(): if self.start_time == 0: self.start_time = time.time() - self.checkForTimeout() + self._checkForTimeout() def sendAllQueue(self): - while not self.tcQueue.__len__() == 0: + while not self._tcQueue.__len__() == 0: self.sendAndPrintTc() def sendAndPrintTc(self): - self.checkQueueEntry(self.tcQueue.pop()) - if self.queueEntryIsTelecommand: + self._checkQueueEntry(self._tcQueue.pop()) + if self.__queueEntryIsTelecommand: self.tcInfoQueue.append(self.pusPacketInfo) self._comInterface.sendTelecommand(self.pusPacket, self.pusPacketInfo) self.handleWaiting() diff --git a/sendreceive/OBSW_SequentialSenderReceiver.py b/sendreceive/OBSW_SequentialSenderReceiver.py index a784288..7d1f4d7 100644 --- a/sendreceive/OBSW_SequentialSenderReceiver.py +++ b/sendreceive/OBSW_SequentialSenderReceiver.py @@ -35,18 +35,17 @@ class SequentialCommandSenderReceiver(CommandSenderReceiver): super().__init__( comInterface=comInterface, tmtcPrinter=tmtcPrinter, tmListener=tmListener, tmTimeout=tmTimeout, tcSendTimeoutFactor=tcTimeoutFactor, doPrintToFile=doPrintToFile) - self.tcQueue = tcQueue - self.firstReplyReceived = False - self.allRepliesReceived = False - self.start_time = 0 - self.elapsed_time = 0 - self.abortFlag = False - self.modeOpFinished = False + self._tcQueue = tcQueue + self.__start_time = 0 + self.__elapsed_time = 0 + self.__firstReplyReceived = False + self.__allRepliesReceived = False + self.__modeOpFinished = False def sendQueueTcAndReceiveTmSequentially(self): self._tmListener.modeId = g.ModeList.ServiceTestMode self._tmListener.modeChangeEvent.set() - self.sendAndReceiveFirstPacket() + self.__sendAndReceiveFirstPacket() # this flag is set in the separate thread ! try: self.handleTcSending() @@ -56,47 +55,48 @@ class SequentialCommandSenderReceiver(CommandSenderReceiver): # self.handleInterrupt(receiverThread) def handleTcSending(self): - while not self.allRepliesReceived: - while not self.tcQueue.__len__() == 0: - self.performNextTcSend() - if self.tcQueue.__len__() == 0: - self.start_time = time.time() - self.checkForTimeout() - if not self.modeOpFinished: + while not self.__allRepliesReceived: + while not self._tcQueue.__len__() == 0: + self.__performNextTcSend() + if self._tcQueue.__len__() == 0: + self.__start_time = time.time() + self._checkForTimeout() + if not self.__modeOpFinished: self._tmListener.modeOpFinished.set() + self.__modeOpFinished = True print("Sequential SenderReceiver: All replies received!") if self.doPrintToFile: print("Sequential SenderReceiver: Exporting output to log file.") self._tmtcPrinter.printToFile() - def performNextTcSend(self): + def __performNextTcSend(self): if self._tmListener.replyEvent.is_set(): self.replyReceived = True self._tmListener.replyEvent.clear() # this flag is set in the separate receiver thread too if self.replyReceived: - self.sendNextTelecommand() + self.__sendNextTelecommand() self.replyReceived = False # just calculate elapsed time if start time has already been set (= command has been sent) else: - self.checkForTimeout() + self._checkForTimeout() - def sendAndReceiveFirstPacket(self): - self.checkQueueEntry(self.tcQueue.pop()) - if self.queueEntryIsTelecommand: + def __sendAndReceiveFirstPacket(self): + self._checkQueueEntry(self._tcQueue.pop()) + if self.__queueEntryIsTelecommand: self._comInterface.sendTelecommand(self.pusPacket, self.pusPacketInfo) else: - self.sendAndReceiveFirstPacket() + self.__sendAndReceiveFirstPacket() - def sendNextTelecommand(self): - self.checkQueueEntry(self.tcQueue.pop()) - if self.queueEntryIsTelecommand: - self.start_time = time.time() + def __sendNextTelecommand(self): + self._checkQueueEntry(self._tcQueue.pop()) + if self.__queueEntryIsTelecommand: + self.__start_time = time.time() self._comInterface.sendTelecommand(self.pusPacket, self.pusPacketInfo) - elif self.tcQueue.__len__() == 0: + elif self._tcQueue.__len__() == 0: # Special case: Last queue entry is not a Telecommand - self.allRepliesReceived = True + self.__allRepliesReceived = True else: # If the queue entry was not a telecommand, send next telecommand - self.performNextTcSend() + self.__performNextTcSend() diff --git a/sendreceive/OBSW_SingleCommandSenderReceiver.py b/sendreceive/OBSW_SingleCommandSenderReceiver.py index e95d913..4e3f5f5 100644 --- a/sendreceive/OBSW_SingleCommandSenderReceiver.py +++ b/sendreceive/OBSW_SingleCommandSenderReceiver.py @@ -30,23 +30,23 @@ class SingleCommandSenderReceiver(CommandSenderReceiver): """ super().__init__(comInterface=comInterface, tmListener=tmListener, tmtcPrinter=tmtcPrinter, tmTimeout=tmTimeout, tcSendTimeoutFactor=tcTimeoutFactor, doPrintToFile=doPrintToFile) - self.pusPacketTuple = pusPacketTuple try: - (self.pusPacketInfo, self.pusPacket) = self.pusPacketTuple + (self.pusPacketInfo, self.pusPacket) = pusPacketTuple except TypeError: print("Invalid queue entry detected") - logging.exception("Error: ") - exit() + logging.exception("Error") + self.faultyInput = True def sendSingleTcAndReceiveTm(self): - self._tmListener.modeId = g.ModeList.SingleCommandMode - self._tmListener.modeChangeEvent.set() - self._comInterface.sendTelecommand(self.pusPacket, self.pusPacketInfo) - while not self.replyReceived: - # wait until reply is received - super().checkForFirstReply() - if self.replyReceived: - print("Single Command SenderReceiver: Reply received") - self._tmListener.modeOpFinished.set() - print("Listening for packages ...") + if not self.faultyInput: + self._tmListener.modeId = g.ModeList.SingleCommandMode + self._tmListener.modeChangeEvent.set() + self._comInterface.sendTelecommand(self.pusPacket, self.pusPacketInfo) + while not self._replyReceived: + # wait until reply is received + super()._checkForFirstReply() + if self._replyReceived: + print("Single Command SenderReceiver: Reply received") + self._tmListener.modeOpFinished.set() + print("Listening for packages ...") diff --git a/tc/OBSW_TcPacket.py b/tc/OBSW_TcPacket.py index f23cbf3..fd6e75a 100644 --- a/tc/OBSW_TcPacket.py +++ b/tc/OBSW_TcPacket.py @@ -37,7 +37,7 @@ class PUSTelecommand: self.data = data # print("Apid:" + str(self.apid)) - def getLength(self): + def getLength(self) -> int: try: length = 4 + len(self.data) + 1 return length @@ -94,14 +94,14 @@ class PUSTelecommand: # Takes pusPackets, removes current Packet Error Control, calculates new CRC (16 bits at packet end) and # adds it as correct Packet Error Control Code. Reference: ECSS-E70-41A p. 207-212 -def generatePacketCRC(TCPacket): +def generatePacketCRC(TCPacket: PusTcT) -> PusTcT: crc_func = crcmod.mkCrcFun(0x11021, rev=False, initCrc=0xFFFF, xorOut=0x0000) crc = crc_func(bytearray(TCPacket[0:len(TCPacket) - 2])) TCPacket[len(TCPacket) - 2] = (crc & 0xFF00) >> 8 TCPacket[len(TCPacket) - 1] = crc & 0xFF -def generateCRC(data): +def generateCRC(data: bytearray) -> bytearray: dataWithCRC = bytearray() dataWithCRC += data crc_func = crcmod.mkCrcFun(0x11021, rev=False, initCrc=0xFFFF, xorOut=0x0000) diff --git a/test/OBSW_UnitTest.py b/test/OBSW_UnitTest.py index e62c827..6aa86e7 100644 --- a/test/OBSW_UnitTest.py +++ b/test/OBSW_UnitTest.py @@ -39,7 +39,6 @@ from sendreceive.OBSW_MultipleCommandsSenderReceiver import MultipleCommandSende from config import OBSW_Config as g from tm.OBSW_PusTm import pusTmInfoQueueT, pusTmInfoT from tc.OBSW_TcPacket import pusTcInfoQueueT -import pprint as pp TmInfoQueueService1T = Deque[pusPacketInfoService1T] @@ -49,7 +48,6 @@ class TestService(unittest.TestCase): Generic service test class. See documentation: https://docs.python.org/3/library/unittest.html#unittest.TestCase.setUpClass """ - @classmethod def setUpClass(cls): """ @@ -80,8 +78,8 @@ class TestService(unittest.TestCase): # This function should be called in each individual test to send the actual telecommands # which are stored inside testQueue def performTestingAndGenerateAssertionDict(self): - # Maybe we should instantiate this once in the main and then reuse it instead of calling the constructor - # over and over again. + # TODO: Maybe we should instantiate this once in the main and then reuse it instead of calling the constructor + # over and over again. UnitTester = MultipleCommandSenderReceiver( comInterface=self.communicationInterface, tmtcPrinter=self.tmtcPrinter, tmListener=self.tmListener, tcQueue=self.testQueue, tmTimeout=self.tmTimeout, waitIntervals=self.waitIntervals, waitTime=self.waitTime, @@ -197,8 +195,6 @@ class TestService(unittest.TestCase): cls.tcVerifyCounter = 0 # noinspection PyUnresolvedReferences cls.testQueue.clear() - # if g.comIF == 1: - # cls.communicationInterface.close() class TestDummyDevice(TestService): -- GitLab