Added Telemetry parsing

This patch adds telemetry packet parsing and unit tests.

Author: hemna

aprslib/parsing/__init__.py

@@ -57,7 +57,6 @@ def detect(x):
         '.':'reserved',
         '<':'station capabilities',
         '?':'general query format',
-        'T':'telemetry report',
         '[':'maidenhead locator beacon',
         '\\':'unused',
         ']':'unused',
@@ -202,6 +201,12 @@ def _try_toparse_body(packet_type, body, parsed):
 
         body, result = parse_weather(body)
 
+    # Telemetry report
+    elif packet_type == 'T':
+        logger.debug("Attempting to parse as telemetry report")
+
+        body, result = parse_telemetry_report(body)
+
     # postion report (regular or compressed)
     elif (packet_type in '!=/@;' or
           0 <= body.find('!') < 40):  # page 28 of spec (PDF)

aprslib/parsing/telemetry.py

@@ -6,6 +6,7 @@
 __all__ = [
         'parse_comment_telemetry',
         'parse_telemetry_config',
+        'parse_telemetry_report',
         ]
 
 
@@ -85,9 +86,11 @@ def parse_telemetry_config(body):
                 't%s' % form: teqns
                 })
         elif form == "BITS":
-            match = re.findall(r"^([01]{8}),(.{0,23})$", body.rstrip())
+            # APRS spec says 23 chars, but real-world packets may be longer
+            # Accept any reasonable length (up to 100 chars to be safe)
+            match = re.findall(r"^([01]{8}),(.{0,100})$", body.rstrip())
             if not match:
-                raise ParseError("incorrect format of %s (title too long?)" % form)
+                raise ParseError("incorrect format of %s" % form)
 
             bits, title = match[0]
 
@@ -98,3 +101,111 @@ def parse_telemetry_config(body):
 
     return (body, parsed)
 
+
+def parse_telemetry_report(body):
+    """
+    Parses APRS 1.2 telemetry report format: T#sss,aaa,bbb,ccc,ddd,eee,bbbbbbbb,comment
+
+    Format:
+    - T# indicates telemetry report
+    - sss is sequence number (000-999)
+    - aaa to eee are 5 analog values (000-999)
+    - bbbbbbbb is 8 binary digits (digital I/O)
+    - comment is optional text
+
+    Returns (remaining_body, parsed_dict)
+    """
+    parsed = {}
+
+    # Check if body starts with '#'
+    if not body.startswith('#'):
+        raise ParseError("telemetry report must start with '#'")
+
+    # Remove the '#' prefix
+    body = body[1:]
+
+    # Split by comma - need at least sequence number
+    # Some real-world packets are incomplete (missing analog values or digital I/O)
+    parts = body.split(',', 7)
+
+    if len(parts) < 1:
+        raise ParseError("telemetry report must have at least a sequence number")
+
+    seq_str = parts[0]
+    # Extract analog values (up to 5, pad with empty strings if missing)
+    analog_strs = parts[1:6] if len(parts) > 1 else []
+    # Pad to 5 analog values if we have fewer
+    while len(analog_strs) < 5:
+        analog_strs.append('')
+    
+    # Digital I/O field (may be missing)
+    digital_field = parts[6] if len(parts) > 6 else '00000000'
+    comment = parts[7] if len(parts) > 7 else ''
+
+    # Validate and parse sequence number (allow any positive integer)
+    # APRS spec says 000-999, but real-world packets use larger numbers
+    if not re.match(r'^\d+$', seq_str):
+        raise ParseError("telemetry sequence number must be numeric")
+    seq = int(seq_str)
+
+    # Parse analog values (can be 000-999, allow decimals and negatives per APRS 1.2)
+    # Empty values are allowed and treated as 0
+    analog_vals = []
+    for i, val_str in enumerate(analog_strs):
+        # Allow empty values (treated as 0)
+        if not val_str or val_str.strip() == '':
+            analog_vals.append(0.0)
+            continue
+        
+        # Allow integers, decimals, and negative numbers
+        if not re.match(r'^-?\d+\.?\d*$', val_str):
+            raise ParseError("telemetry analog value %d has invalid format" % (i+1))
+        try:
+            val = float(val_str)
+        except ValueError:
+            raise ParseError("telemetry analog value %d is not a valid number" % (i+1))
+        analog_vals.append(val)
+
+    # Validate digital I/O (must be binary digits, pad to 8 if shorter)
+    # Some packets have comment concatenated without comma separator
+    # Some packets have shorter binary strings (pad with leading zeros)
+    # Check if field is entirely binary digits
+    if re.match(r'^[01]+$', digital_field):
+        # Pure binary string (all 0s and 1s)
+        if len(digital_field) < 8:
+            # Pad shorter binary strings to 8 digits
+            digital_str = digital_field.zfill(8)
+        elif len(digital_field) == 8:
+            digital_str = digital_field
+        else:
+            # Longer than 8, use first 8
+            digital_str = digital_field[:8]
+    elif re.match(r'^[01]{8,}[^01]', digital_field):
+        # Starts with 8+ binary digits followed by non-binary (concatenated comment)
+        digital_str = digital_field[:8]
+        if not comment:
+            comment = digital_field[8:]
+    elif re.match(r'^[01]{1,7}[^01]', digital_field):
+        # Starts with 1-7 binary digits followed by non-binary
+        # This is invalid - need at least 8 binary digits before comment
+        raise ParseError("telemetry digital I/O must be binary digits")
+    else:
+        # No valid binary digits found or invalid format
+        raise ParseError("telemetry digital I/O must be binary digits")
+
+    parsed.update({
+        'format': 'telemetry',
+        'telemetry': {
+            'seq': seq,
+            'vals': analog_vals,
+            'bits': digital_str
+        }
+    })
+
+    # Add comment if present
+    if comment:
+        parsed['comment'] = comment.strip(' ')
+
+    # Return empty remaining body since we consumed everything
+    return ('', parsed)
+