diff --git a/sendreceive/obsw_tm_listener.py b/sendreceive/obsw_tm_listener.py
index 500dcf258ec620332a62fe1501bcb01eb6a0e761..a415a9c1bc624963934b624cec2f70f5e596a243 100644
--- a/sendreceive/obsw_tm_listener.py
+++ b/sendreceive/obsw_tm_listener.py
@@ -46,7 +46,7 @@ class TmListener:
         # UPDATE: Right now, the main program is not in a permanent loop and setting the
         # thread daemonic will cancel the program.
         # Solved for now by setting a permanent loop at the end of the main program
-        self.listener_thread = threading.Thread(target=self.perform_operation, daemon=True)
+        self.listener_thread = threading.Thread(target=self.__perform_operation, daemon=True)
         self.lock_listener = threading.Lock()
         # This Event is set by sender objects to perform mode operations
         self.event_mode_change = threading.Event()
@@ -69,25 +69,46 @@ class TmListener:
     def start(self):
         self.listener_thread.start()
 
-    def perform_operation(self):
+    def tm_received(self):
+        """
+        This  function is used to check whether any data has been received
+        """
+        if self.__tm_packet_queue.__len__() > 0:
+            return True
+        else:
+            return False
+
+    def retrieve_tm_packet_queue(self) -> PusTmQueueT:
+        if self.lock_listener.acquire(True, timeout=1):
+            tm_queue_copy = self.__tm_packet_queue.copy()
+        else:
+            tm_queue_copy = self.__tm_packet_queue.copy()
+            LOGGER.critical("TmListener: Blocked on lock acquisition for longer than 1 second!")
+        self.lock_listener.release()
+        return tm_queue_copy
+    
+    def clear_tm_packet_queue(self):
+        self.__tm_packet_queue.clear()
+
+    def __perform_operation(self):
         while True:
             if self.event_listener_active.is_set():
-                self.default_operation()
+                self.__default_operation()
             else:
                 time.sleep(1)
 
-    def default_operation(self):
+    def __default_operation(self):
         """
         Core function. Normally, polls all packets
         """
-        self.perform_core_operation()
+        self.__perform_core_operation()
         if self.event_mode_change.is_set():
             self.event_mode_change.clear()
             start_time = time.time()
             while not self.event_mode_op_finished.is_set():
                 elapsed_time = time.time() - start_time
                 if elapsed_time < TmListener.MODE_OPERATION_TIMEOUT:
-                    self.perform_mode_operation()
+                    self.__perform_mode_operation()
                 else:
                     LOGGER.warning("TmListener: Mode operation timeout occured!")
                     break
@@ -95,7 +116,7 @@ class TmListener:
             LOGGER.info("TmListener: Transitioning to listener mode.")
             self.mode_id = g.ModeList.ListenerMode
 
-    def perform_core_operation(self):
+    def __perform_core_operation(self):
         packet_list = self.com_interface.receive_telemetry()
         if len(packet_list) > 0:
             if self.lock_listener.acquire(True, timeout=1):
@@ -104,7 +125,7 @@ class TmListener:
                 LOGGER.error("TmListener: Blocked on lock acquisition!")
             self.lock_listener.release()
 
-    def perform_mode_operation(self):
+    def __perform_mode_operation(self):
         """
         By setting the modeChangeEvent with set() and specifying the mode variable,
         the TmListener is instructed to perform certain operations.
@@ -128,7 +149,7 @@ class TmListener:
         elif self.mode_id == g.ModeList.UnitTest:
             # TODO: needs to be reworked. Info queue is stupid. just pop the normal queue and
             #       pack the information manually
-            self.perform_core_operation()
+            self.__perform_core_operation()
 
     def check_for_one_telemetry_sequence(self) -> bool:
         """
@@ -173,15 +194,6 @@ class TmListener:
             self.tm_timeout = g.G_TM_TIMEOUT
         return True
 
-    def retrieve_tm_packet_queue(self) -> PusTmQueueT:
-        if self.lock_listener.acquire(True, timeout=1):
-            tm_queue_copy = self.__tm_packet_queue.copy()
-        else:
-            tm_queue_copy = self.__tm_packet_queue.copy()
-            LOGGER.critical("TmListener: Blocked on lock acquisition for longer than 1 second!")
-        self.lock_listener.release()
-        return tm_queue_copy
-
     @staticmethod
     def retrieve_info_queue_from_packet_queue(
             tm_queue: PusTmQueueT, pus_info_queue_to_fill: PusTmInfoQueueT):
@@ -191,6 +203,5 @@ class TmListener:
             for pus_packet in pus_packet_list:
                 pus_info_queue_to_fill.append(pus_packet.pack_tm_information())
 
-    def clear_tm_packet_queue(self):
-        self.__tm_packet_queue.clear()
+