Merge branch 'new-packet-format' of https://github.com/CarletonURocketry/ground-station into new-packet-format

Author: Juan-789

Dockerfile

@@ -1,28 +1,24 @@
 # Python-slim base image
 FROM python:3.11-slim
 
-MAINTAINER Jacob Terkuc
+LABEL MAINTAINER="Jacob Terkuc"
+LABEL MAINTAINER="Elias Hawa"
 
 # Update and upgrade packages
 RUN apt-get update && apt-get upgrade -y && pip install --upgrade pip
 
-# Install Virtual Env
-RUN pip install virtualenv
-
 # Set the working directory in the container
 WORKDIR /app/ground-station
 
 # Copy files
-COPY . .
-
-# Set up VENV and "source"
-ENV VIRTUAL_ENV=/app/ground-station
-RUN python3 -m venv $VIRTUAL_ENV
-ENV PATH="$VIRTUAL_ENV/bin:$PATH"
+COPY requirements.txt .
 
 # Install any needed packages specified in requirements.txt
 RUN pip install -r requirements.txt
 
+# Copy files
+COPY . .
+
 # Expose port 33845
 EXPOSE 33845/udp
 

config.json

@@ -7,16 +7,16 @@
     "frequency": 433050000,
     "power": 15,
     "spread_factor": 7,
-    "coding_rate": "4/7",
-    "bandwidth": 500,
+    "coding_rate": "4/5",
+    "bandwidth": 125,
     "preamble_len": 6,
     "cyclic_redundancy": true,
-    "iqi": false,
-    "sync_word": "0x43"
+    "iqi": false
   },
   "approved_callsigns": {
     "VA3INI": "Matteo Golin",
     "VA3ZTA": "Darwin Jull",
-    "VE3LWN": "Thomas Selwyn"
+    "VE3LWN": "Thomas Selwyn",
+    "VA3EHJ": "Elias Hawa"
   }
 }

modules/misc/config.py

@@ -66,7 +66,7 @@ class RadioParameters:
     preamble_len: int = 6
     cyclic_redundancy: bool = True
     iqi: bool = False
-    sync_word: str = "0x43"
+    # sync_word: str = "0x43"
 
     def __post_init__(self):
         if self.frequency not in range(*LF_RANGE) and self.frequency not in range(*HF_RANGE):
@@ -83,9 +83,9 @@ def __post_init__(self):
         if self.preamble_len not in range(*PREAMBLE_RANGE):
             raise ValueError(f"Preamble length '{self.preamble_len}' not within allowed range of {PREAMBLE_RANGE}")
 
-        if int(self.sync_word, 16) not in range(*SYNC_RANGE):
-            raise ValueError(f"Sync word '{self.sync_word}' not within allowed range of {SYNC_RANGE}")
-        self.sync_word = self.sync_word[2:]  # Remove 0x
+        # if int(self.sync_word, 16) not in range(*SYNC_RANGE):
+        #     raise ValueError(f"Sync word '{self.sync_word}' not within allowed range of {SYNC_RANGE}")
+        # self.sync_word = self.sync_word[2:]  # Remove 0x
 
     @classmethod
     def from_json(cls, data: JSON) -> Self:
@@ -103,7 +103,7 @@ def from_json(cls, data: JSON) -> Self:
             preamble_len=data.get("preamble_len", 6),
             cyclic_redundancy=data.get("cyclic_redundancy", True),
             iqi=data.get("iqi", False),
-            sync_word=data.get("sync_word", "0x43"),
+            # sync_word=data.get("sync_word", "0x43"),
         )
 
     def __iter__(self):
@@ -116,7 +116,7 @@ def __iter__(self):
         yield "preamble_len", self.preamble_len
         yield "cyclic_redundancy", self.cyclic_redundancy
         yield "iqi", self.iqi
-        yield "sync_word", self.sync_word
+        # yield "sync_word", self.sync_word
 
 
 @dataclass

modules/serial/rn2483_radio.py

@@ -36,7 +36,7 @@
     "preamble_len": "prlen",
     "cyclic_redundancy": "crc",
     "iqi": "iqi",
-    "sync_word": "sync",
+    # "sync_word": "sync",
 }
 
 

modules/telemetry/parsing_utils.py

@@ -3,14 +3,16 @@
 import logging
 
 
-from modules.telemetry.v1.block import (
-    PacketHeader,
-    BlockHeader,
-    DeviceAddress,
-    UnsupportedEncodingVersionError,
-    InvalidHeaderFieldValueError,
-)
-import modules.telemetry.v1.data_block as v1db
+# from modules.telemetry.v1.block import (
+#     PacketHeader,
+#     BlockHeader,
+#     DeviceAddress,
+#     UnsupportedEncodingVersionError,
+#     InvalidHeaderFieldValueError,
+# )
+# import modules.telemetry.v1.data_block as v1db
+
+from modules.telemetry.v2.block import *
 from modules.misc.config import Config
 
 MIN_SUPPORTED_VERSION: int = 1
@@ -54,48 +56,51 @@ def parse_rn2483_transmission(data: str, config: Config) -> Optional[ParsedTrans
 
     # Catch unsupported encoding versions by skipping packet
     try:
-        pkt_hdr = PacketHeader.from_hex(data[:32])
-    except UnsupportedEncodingVersionError as e:
+        pkt_hdr: PacketHeader = parse_packet_header(data[:PACKET_HEADER_LENGTH])
+    except InvalidHeaderFieldValueError as e:
         logger.error(f"{e}, skipping packet")
         return
+    
+    logger.info(pkt_hdr)
 
     # We can keep unauthorized callsigns but we'll log them as warnings
     from_approved_callsign(pkt_hdr, config.approved_callsigns)
 
-    if len(pkt_hdr) <= 32:  # If this packet nothing more than just the header
+    if len(pkt_hdr) <= PACKET_HEADER_LENGTH:  # If this packet nothing more than just the header
         logger.debug(f"{pkt_hdr}")
 
-    blocks = data[32:]  # Remove the packet header
+    blocks = data[PACKET_HEADER_LENGTH:]  # Remove the packet header
 
     # Parse through all blocks
     while blocks != "":
         # Parse block header
         logger.debug(f"Blocks: {blocks}")
-        logger.debug(f"Block header: {blocks[:8]}")
+        logger.debug(f"Block header: {blocks[:BLOCK_HEADER_LENGTH]}")
 
         # Catch invalid block headers field values by skipping packet
         try:
-            block_header = BlockHeader.from_hex(blocks[:8])
+            block_header = parse_block_header(blocks[:BLOCK_HEADER_LENGTH])
         except InvalidHeaderFieldValueError as e:
             logger.error(f"{e}, skipping packet")
             return
+        logger.info(block_header)
 
         # Select block contents
-        block_len = len(block_header) * 2  # Convert length in bytes to length in hex symbols
-        block_contents = blocks[8:block_len]
-        logger.debug(f"Block info: {block_header}")
-
-        # Check if message is destined for ground station for processing
-        if block_header.destination in [DeviceAddress.GROUND_STATION, DeviceAddress.MULTICAST]:
-            cur_block = parse_radio_block(pkt_hdr.version, block_header, block_contents)
-            if cur_block:
-                parsed_blocks.append(cur_block)  # Append parsed block to list
-        else:
-            logger.warning("Invalid destination address")
-
-        # Remove the data we processed from the whole set, and move onto the next data block
-        blocks = blocks[block_len:]
-    return ParsedTransmission(pkt_hdr, parsed_blocks)
+    #     block_len = len(block_header) * 2  # Convert length in bytes to length in hex symbols
+    #     block_contents = blocks[8:block_len]
+    #     logger.debug(f"Block info: {block_header}")
+
+    #     # Check if message is destined for ground station for processing
+    #     if block_header.destination in [DeviceAddress.GROUND_STATION, DeviceAddress.MULTICAST]:
+    #         cur_block = parse_radio_block(pkt_hdr.version, block_header, block_contents)
+    #         if cur_block:
+    #             parsed_blocks.append(cur_block)  # Append parsed block to list
+    #     else:
+    #         logger.warning("Invalid destination address")
+
+    #     # Remove the data we processed from the whole set, and move onto the next data block
+    #     blocks = blocks[block_len:]
+    # return ParsedTransmission(pkt_hdr, parsed_blocks)
 
 
 def from_approved_callsign(pkt_hdr: PacketHeader, approved_callsigns: dict[str, str]) -> bool:

modules/telemetry/v2/block.py

@@ -9,6 +9,8 @@
 
 MIN_SUPPORTED_VERSION: int = 1
 MAX_SUPPORTED_VERSION: int = 1
+PACKET_HEADER_LENGTH: int = 26
+BLOCK_HEADER_LENGTH: int = 2
 
 # Set up logging
 logger = logging.getLogger(__name__)
@@ -59,12 +61,14 @@ class BlockHeader:
 
 #Parse packet header
 def parse_packet_header(header_bytes: bytes) -> PacketHeader:
-    callsign_bytes = header_bytes[:9]
-    callsign = ''
-    for c in callsign_bytes:
-       callsign += chr(c) 
-    timestamp, num_blocks, packet_num = struct.unpack("<HBB", header_bytes[9:])
-    return PacketHeader(callsign, timestamp, num_blocks, packet_num)
+    try: 
+        logger.info(header_bytes)
+        callsign_bytes = header_bytes[:18]
+        callsign = bytes.fromhex(callsign_bytes) 
+        timestamp, num_blocks, packet_num = struct.unpack("<HBB", bytes(header_bytes[18:]))
+        return PacketHeader(callsign, timestamp, num_blocks, packet_num)
+    except ValueError as e:
+        raise InvalidHeaderFieldValueError(e)
 
 #Parse block header
 def parse_block_header(header_bytes: bytes) -> BlockHeader: