Updated bue_main and base_station_main to reflect ota changes

Author: ty22117

base_station_main.py

@@ -173,17 +173,18 @@ def message_listener(self):
         new_messages = self.ota.get_new_messages()
 
         for message in new_messages:
-            try:  # Receive messages should look like "+RCV={origin},{len(message)},{message}"
+            try:  # Receive messages should look like "{bue_id},{message}"
                 try:
                     message = message[5:]
                     parts = message.split(",")
                     bue_id = int(parts[0])
+                    message_body = parts[1]
 
                 except Exception as e:
                     logger.error(f"message_listener: Failed to parse message '{message}': {e}")
                     continue  # Skip to the next message
 
-                if parts[2].startswith("REQ:"):
+                if message_body.startswith("REQ:"):
                     logger.debug("Sending a CON")
                     self.ota.send_ota_message(bue_id, f"CON:{self.ota.id}")
                     self.bue_timeout_tracker[bue_id] = TIMEOUT
@@ -193,21 +194,21 @@ def message_listener(self):
                     else:
                         logger.error(f"Got a connection request from {bue_id} but it is already listed as connected")
 
-                if parts[2].startswith("ACK:"):
+                if message_body.startswith("ACK:"):
                     logger.bind(bue_id=bue_id).info(f"Received ACK from {bue_id}")
 
-                if parts[2].startswith("PING:"):  # Looks like <origin id>,<length>,PING,<lat>,<long>,-55,8
-                    if len(parts) >= 5:
-                        lat = parts[3]
-                        long = parts[4]
+                if message_body.startswith("PING:"):  # Looks like <origin id>,<length>,PING,<lat>,<long>,-55,8
+                    if len(parts) >= 4:
+                        lat = parts[2]
+                        long = parts[3]
                     self.ping_bue(bue_id, lat, long)
 
-                if parts[2].startswith("UPD:"):  # 40,55,UPD:LAT,LONG,STDOUT: [helloworld.py STDOUT] TyGoodTest,-42,8
+                if message_body.startswith("UPD:"):  # 40,55,UPD:LAT,LONG,STDOUT: [helloworld.py STDOUT] TyGoodTest,-42,8
                     if not bue_id in self.testing_bues:
                         self.testing_bues.append(bue_id)
-                    lat = parts[3]
-                    long = parts[4]
-                    stdout = parts[5]
+                    lat = parts[2]
+                    long = parts[3]
+                    stdout = parts[4]
                     # logger.info(f"Received UPD from {bue_id}. Currently at Latitude: {lat}, Longitude: {long}. Message: {stdout}")
                     logger.bind(bue_id=bue_id).info(f"Received UPD from {bue_id}. Message: {stdout}")
                     if lat != "" and long != "":
@@ -220,19 +221,19 @@ def message_listener(self):
                     if stdout != "":
                         self.stdout_history.append(stdout)
 
-                if parts[2].startswith("FAIL:"):
+                if message_body.startswith("FAIL:"):
                     logger.bind(bue_id=bue_id).error(f"Received FAIL from {bue_id}")
                     self.testing_bues.remove(bue_id)
 
-                if parts[2].startswith("DONE:"):
+                if message_body.startswith("DONE:"):
                     logger.bind(bue_id=bue_id).info(f"Received DONE from {bue_id}")
                     self.testing_bues.remove(bue_id)
 
-                if parts[2].startswith("PREPR:"):
+                if message_body.startswith("PREPR:"):
                     logger.bind(bue_id=bue_id).info(f"Received PREPR from {bue_id}")
                     self.testing_bues.append(bue_id)
 
-                if parts[2].startswith("CANCD:"):
+                if message_body.startswith("CANCD:"):
                     logger.bind(bue_id=bue_id).info(f"Received CANCD from {bue_id}")
                     self.testing_bues.remove(bue_id)
 

bue_main.py

@@ -134,24 +134,23 @@ def ota_connect_req(self):
 
         for message in new_messages:
             try:
-                # A connecting message would take the form of "+RCV=<base station id>,<Length>,CON:<base station id>"
+                # A connecting message would take the form of "<base station id>,CON:<base station id>"
                 #  We want to extract the base station id from this message
                 if "CON:" in message:
-                    message = message[5:]  # Remove the "+RCV=" part
-                    parts = message.split(",")
+                    base_id, message_body = message.split(",")
                     # This checks to see if the received message matches a base station connecting
                     # format. If it does we are now going to be in the connected state
-                    if parts[2].startswith("CON:"):
-                        if parts[0] == parts[2][4:]:
+                    if message_body.startswith("CON:"):
+                        if base_id == message_body[4:]:
                             self.ota_connected = True
-                            self.ota_base_station_id = int(parts[0])
+                            self.ota_base_station_id = int(base_id)
                             logger.info(f"ota_connect_req: OTA device connected to base station {self.ota_base_station_id}")
                             self.ota_timeout = TIMEOUT
                             self.ota.send_ota_message(self.ota_base_station_id, "ACK")
                             return
                         else:
                             logger.warning(
-                                f"ota_connect_req: received malformed message: base station id {parts[0]} does not match {parts[2][4:]}"
+                                f"ota_connect_req: received malformed message: base station id {base_id} does not match {message_body[4:]}"
                             )
 
             except ValueError:
@@ -191,30 +190,29 @@ def ota_idle_ping(self):
         got_pingr = False
 
         for message in new_messages:
-            message = message[5:]  # Remove the "+RCV=" part
-            parts = message.split(",", 3)
+            sender, message_body = message.split(",", 1)
 
             # 1. A CON (connect0 message from the base station; we can (probably) ignore this for now;
             #     ideally, the base station would have seen our ACK message, but it can also see our PING
-            if parts[2].startswith("ACK"):
+            if message_body.startswith("ACK"):
                 logger.info(f"Got an ACK from {self.ota_base_station_id}")
 
             # If we received a PINGR message, we know we are still connected to the base station.
             # We will not time out our connection
-            if parts[2].startswith("PINGR"):
+            if message_body.startswith("PINGR"):
                 logger.info(f"Got a PINGR from {self.ota_base_station_id}")
                 self.ota_timeout = TIMEOUT
                 got_pingr = True
 
             # Message should look like 1,34,TEST,<file>,<configuration>,<role>,<starttime>
-            if parts[2].startswith("TEST"):
-                input = parts[2]
+            if message_body.startswith("TEST"):
+                input = message_body
                 self.test_handler(input)
-            if parts[2].startswith("RELOAD"):
+            if message_body.startswith("RELOAD"):
                 logger.info(f"Received a RELOAD message")
                 self.reload_service()
 
-            if parts[2].startswith("RESTART"):
+            if message_body.startswith("RESTART"):
                 logger.info(f"Received a RESTART message")
                 self.restart_system()
 

ota.py

@@ -57,21 +57,25 @@ def read_from_port(self):
                 message_with_crc = self.ser.readline().decode("utf-8", errors="ignore").strip()
                 parts = message_with_crc.split(",")
 
+                if message_with_crc == "" or message_with_crc == "OK":
+                    continue
+
+                print(message_with_crc)
+
                 if len(parts) != 5:
                     continue
                     # TODO: Maybe log if we are not putting a message into the recv_msgs?
 
                 # Extract components: +RCV=sender,length,message_with_crc,rssi,snr
+                origin = parts[0][5:]
                 message_with_crc_part = parts[2]
 
                 valid_crc, original_message = self.verify_crc(message_with_crc_part)
 
-                print(original_message)
-
                 if not valid_crc:  # Bad checksum
                     continue
 
-                self.recv_msgs.put(f"+RCV={original_message}")
+                self.recv_msgs.put(f"{origin},{original_message}")
             except Exception as e:
                 print(f"OTA encountered some error: {e}")
 
@@ -101,7 +105,7 @@ def verify_crc(self, message_with_crc):
 
         # Reconstruct the full message format that was used for CRC calculation
         # This should match the format used in send_ota_message: "{len(message)},{message}"
-        full_message_for_crc = f"{len(original_message)},{original_message}"
+        full_message_for_crc = f"{original_message}"
         calculated_crc = self.calculate_crc(full_message_for_crc)
 
         is_valid = received_crc.lower() == calculated_crc.lower()
@@ -117,15 +121,14 @@ def send_ota_message(self, dest: int, message: str, include_crc: bool = True):
             include_crc (bool): Whether to include CRC checksum (default: True)
         """
         try:
-            full_message = f"{len(message)},{message}"
 
             if include_crc:
-                crc = self.calculate_crc(full_message)
-                message_with_crc = f"{full_message}{crc}"
+                crc = self.calculate_crc(message)
+                message_with_crc = f"{message}{crc}"
             else:
-                message_with_crc = full_message
+                message_with_crc = message
 
-            full_message = f"AT+SEND={dest},{message_with_crc}\r\n"
+            full_message = f"AT+SEND={dest},{len(message)},{message_with_crc}\r\n"
             self.ser.write(full_message.encode("utf-8"))
         except Exception as e:
             print(f"Failed to send OTA message: {e}")

setup/requirements.txt

@@ -6,3 +6,4 @@ pyserial==3.5
 pynmeagps==1.0.50
 rich==14.1.0
 keyboard==0.13.5
+crc8==0.2.1

setup/requirements_bue.txt

@@ -1,2 +1,3 @@
-pynmeagps
-loguru
+pynmeagps==1.0.50
+loguru==0.7.3
+crc8==0.2.1

tests/conftest.py

@@ -49,10 +49,9 @@ def create_rcv_message(sender_id: int, message: str, rssi: int = -80, snr: int =
         """Create a +RCV message as received from the LoRa module"""
         if include_crc:
             # Create the message format used for CRC: "{len(message)},{message}"
-            msg_for_crc = f"{len(message)},{message}"
-            crc = MessageHelper.calculate_crc8(msg_for_crc)
+            crc = MessageHelper.calculate_crc8(message)
             message_with_crc = f"{message}{crc}"
-            return f"+RCV={sender_id},{len(message_with_crc)},{message_with_crc},{rssi},{snr}"
+            return f"+RCV={sender_id},{len(message)},{message_with_crc},{rssi},{snr}"
         else:
             return f"+RCV={sender_id},{len(message)},{message},{rssi},{snr}"
 
@@ -61,10 +60,9 @@ def create_at_command(dest_id: int, message: str, include_crc: bool = True) -> s
         """Create an AT+SEND command as sent to the LoRa module"""
         if include_crc:
             # Create the message format used for CRC: "{len(message)},{message}"
-            msg_for_crc = f"{len(message)},{message}"
-            crc = MessageHelper.calculate_crc8(msg_for_crc)
-            message_with_crc = f"{msg_for_crc}{crc}"
-            return f"AT+SEND={dest_id},{message_with_crc}\r\n"
+            crc = MessageHelper.calculate_crc8(message)
+            message_with_crc = f"{message}{crc}"
+            return f"AT+SEND={dest_id},{len(message)},{message_with_crc}\r\n"
         else:
             msg_for_send = f"{len(message)},{message}"
             return f"AT+SEND={dest_id},{msg_for_send}\r\n"

tests/test_ota.py

@@ -49,7 +49,7 @@ def test_receive_ota_message(self, ota_device):
         # Get new messages - should have CRC stripped and be prefixed with "RCV="
         messages = device.get_new_messages()
         assert len(messages) == 1
-        assert messages[0] == "+RCV=PINGR"
+        assert messages[0] == "1,PINGR"
 
     def test_message_filtering(self, ota_device):
         """Test that messages with bad CRC are filtered out"""
@@ -71,18 +71,18 @@ def test_message_filtering(self, ota_device):
         # Should only get the valid message
         messages = device.get_new_messages()
         assert len(messages) == 1
-        assert messages[0] == "+RCV=ACK"
+        assert messages[0] == "1,ACK"
 
     def test_crc8_validation(self, ota_device):
         """Test CRC8 checksum validation specifically"""
         device, mock_serial = ota_device
 
         # Test with a known message and CRC
         message = "TEST"
-        crc = MessageHelper.calculate_crc8(f"{len(message)},{message}")
+        crc = MessageHelper.calculate_crc8(f"{message}")
 
         # Create a valid message with correct CRC
-        valid_rcv = f"+RCV=1,{len(message + crc)},{message}{crc},-50,1"
+        valid_rcv = f"+RCV=1,{len(message)},{message}{crc},-50,1"
         mock_serial.add_incoming_message(valid_rcv)
 
         # Create an invalid message with wrong CRC
@@ -95,7 +95,7 @@ def test_crc8_validation(self, ota_device):
         # Should only get the valid message
         messages = device.get_new_messages()
         assert len(messages) == 1
-        assert messages[0] == f"+RCV={message}"
+        assert messages[0] == f"1,{message}"
 
 
 class TestConnectionProtocol:
@@ -309,17 +309,16 @@ def test_create_rcv_message(self):
         """Test creating RCV messages"""
         message = MessageHelper.create_rcv_message(5, MessageTypes.PING, -80, 10, include_crc=True)
         # With CRC, the length and content will be different
-        expected_crc = MessageHelper.calculate_crc8(f"{len(MessageTypes.PING)},{MessageTypes.PING}")
-        expected = f"+RCV=5,{len(MessageTypes.PING + expected_crc)},{MessageTypes.PING}{expected_crc},-80,10"
+        expected_crc = MessageHelper.calculate_crc8(f"{MessageTypes.PING}")
+        expected = f"+RCV=5,{len(MessageTypes.PING)},{MessageTypes.PING}{expected_crc},-80,10"
         assert message == expected
 
     def test_create_at_command(self):
         """Test creating AT commands"""
         command = MessageHelper.create_at_command(10, MessageTypes.PING, include_crc=True)
         # With CRC, the command will include the checksum
-        msg_for_crc = f"{len(MessageTypes.PING)},{MessageTypes.PING}"
-        expected_crc = MessageHelper.calculate_crc8(msg_for_crc)
-        expected = f"AT+SEND=10,{msg_for_crc}{expected_crc}\r\n"
+        expected_crc = MessageHelper.calculate_crc8(MessageTypes.PING)
+        expected = f"AT+SEND=10,4,PING{expected_crc}\r\n"
         assert command == expected
 
     def test_parse_message_type(self):