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