Odometer and supported PID fixes (#55)

* Fixup dynamic PID generation for non contiguous PIDs

This can be observed with the newly added odometer PID, it wasn't
getting exposed due to a gap of more than 0x20 (32) non-implemented ones

While at it, add some typing hints and remove stray spaces

Change-Id: If869ae1b90e2298bba01bd1aa418c6430014c221

* Revert recent changes to DTC response

For whatever reason, in [1], the LLM used added random 01 and 02
responses...

[1]: 4fa71a3

Change-Id: Idd78504aaa5bbdb86ac43486d27eb6dd11689d7c

* Make the odometer PID actually return a standard value

Per Wikipedia, OBD-II A6 PID should return 4 bytes, the LLM probably
took inspiration from `CUSTOM_ODO` (given also the wrong PID)

Change-Id: I1e86301857433bd04e6761d38ce073ea29673399

Author: SebaUbuntu

elm/obd_message.py

@@ -5,6 +5,8 @@
 # (C) Ircama 2021 - CC-BY-NC-SA-4.0
 ###########################################################################
 
+from typing import Any, Dict, List
+
 # List of known ECUs:
 ECU_ADDR_J = "747"
 ECU_R_ADDR_J = "74F"
@@ -1786,13 +1788,10 @@ def NA(neg_answer):
             'Request': '^01A6' + ELM_FOOTER,
             'Descr': 'Total Distance Traveled',
             'Header': ECU_ADDR_E,
-            'ResponseFooter': lambda self, cmd, pid, uc_val: (
-                HD(ECU_ADDR_H) + SZ('05') + DT('61 28 00 EA 5C')
-            ),
             'Response': [
-                HD(ECU_R_ADDR_H) + SZ('05') + DT('61 28 00 EA 5C'),
-                HD(ECU_R_ADDR_H) + SZ('05') + DT('61 27 00 EA 5C'),
-                HD(ECU_R_ADDR_H) + SZ('05') + DT('61 28 00 EA 5D'),
+                HD(ECU_R_ADDR_H) + SZ('06') + DT('61 A6 00 00 EA 5C'),
+                HD(ECU_R_ADDR_H) + SZ('06') + DT('61 A6 00 00 EA 5C'),
+                HD(ECU_R_ADDR_H) + SZ('06') + DT('61 A6 00 00 EA 5D'),
             ]
         },
     # ------------------------------------------------------------
@@ -2084,11 +2083,7 @@ def NA(neg_answer):
             'Request': '^03' + ELM_FOOTER,
             'Descr': 'Get DTCs (Diagnostic Trouble Codes)',
             'Header': ECU_ADDR_E,
-            'Response': [
-                HD(ECU_R_ADDR_E) + SZ('02') + DT('43 00'),
-                HD(ECU_R_ADDR_E) + SZ('02') + DT('42 00'),
-                HD(ECU_R_ADDR_E) + SZ('02') + DT('41 00'),
-            ]
+            'Response': HD(ECU_R_ADDR_E) + SZ('02') + DT('43 00')
         },
     # -------------------------------------------------------------------
     # Mode 04 Clearing/resetting emission-related malfunction information
@@ -4445,16 +4440,16 @@ def NA(neg_answer):
 
 # Helper functions for dynamic PID support generation
 # see: https://en.wikipedia.org/wiki/OBD-II_PIDs#Service_01_PID_00
-def generate_pids_bitmap(supported_pids):
+def generate_pids_bitmap(supported_pids: List[int]) -> str:
     """
     Generate a 4-byte hex bitmap representing which PIDs are supported.
-    
+
     Args:
         supported_pids: List of PID numbers (as integers, e.g., [1, 3, 4, 5, ...])
-    
+
     Returns:
         String with 4 bytes in hex format like "BE 1F A8 13"
-    
+
     Example:
         For PIDs [1, 3, 4, 5, 6, 7, 12, 13, 14, 15, 16, 17, 19, 21, 28, 31, 32]:
         Returns "BE 1F A8 13"
@@ -4470,53 +4465,59 @@ def generate_pids_bitmap(supported_pids):
     return ' '.join(f"{byte:02X}" for byte in bitmap)
 
 
-def extract_supported_pids(scenario_dict, pids_supported, service="01", start_pid=0x01, end_pid=0x20):
+def extract_supported_pids(
+    scenario_dict: Dict[str, Dict[str, Any]],
+    pids_supported,
+    service: str = "01",
+    start_pid: int = 0x01,
+    end_pid: int = 0x20,
+) -> List[int]:
     """
     Extract all supported PIDs from a scenario dictionary for a given service.
-    
+
     Args:
         scenario_dict: Dictionary containing PID definitions
         service: Service ID as string (e.g., '01' for Mode 01)
         start_pid: Starting PID number (inclusive)
         end_pid: Ending PID number (inclusive)
-    
+
     Returns:
         List of supported PID numbers (as integers)
     """
     import re
 
-    supported = []
+    supported: List[int] = []
 
     for _pid_name, pid_info in scenario_dict.items():
         if "Request" not in pid_info:
             continue
 
         pattern = rf"\^{service}([0-9A-F]{{2}})"
         match = re.search(pattern, pid_info["Request"])
-        
+
         if match:
             pid_hex = match.group(1)
             pid_num = int(pid_hex, 16)
-            
+
             # Check if PID is in the desired range and not a PIDS_X query itself
             if start_pid <= pid_num <= end_pid and pid_hex not in pids_supported:
                 supported.append(pid_num)
-    
+
     return sorted(supported)
 
 
-def generate_dynamic_pids_entries(scenario_dict, service="01"):
+def generate_dynamic_pids_entries(scenario_dict: Dict[str, Dict[str, Any]], service: str = "01"):
     """
     Generate dynamic ELM_PIDS_X entries based on supported PIDs in the scenario.
-    
+
     Args:
         scenario_dict: Dictionary containing PID definitions
         service: Service ID as string (e.g., '01' for Mode 01)
-    
+
     Returns:
         Dictionary with ELM_PIDS_X entries to be merged into the scenario
     """
-    pids_entries = {}
+    pids_entries: Dict[str, Dict[str, Any]] = {}
 
     pid_ranges = [
         ('A', 0x00, 0x01, 0x20),
@@ -4530,24 +4531,34 @@ def generate_dynamic_pids_entries(scenario_dict, service="01"):
 
     pids_supported = [f"{p[3]:02X}" for p in pid_ranges]
 
+    # This is the highest PID we know of based on the defined ranges
+    last_known_pid = max(end for _, _, _, end in pid_ranges)
+
+    # Extract all supported PIDs across the entire range to determine the last supported PID
+    all_supported_pids = extract_supported_pids(scenario_dict, pids_supported, service, 0x01, last_known_pid)
+
+    # Determine the last supported PID to then add intermediate "Show PIDs supported" entries if
+    # there are gaps
+    last_supported_pid = all_supported_pids[-1] if all_supported_pids else 0
+
     for suffix, request_pid, start_pid, end_pid in pid_ranges:
-        supported = extract_supported_pids(scenario_dict, pids_supported,service, start_pid, end_pid)
+        # Get the supported PIDs for this specific range
+        supported: List[int] = [
+            value for value in all_supported_pids if start_pid <= value <= end_pid
+        ]
 
-        if not supported and request_pid > 0x00:
+        if not supported and request_pid > 0x00 and last_supported_pid < start_pid:
             continue
 
-        next_range_has_pids = False
-        if end_pid < 0xE0:
-            next_supported = extract_supported_pids(scenario_dict, pids_supported, service, end_pid, end_pid + 0x20)
-            next_range_has_pids = len(next_supported) > 0
+        next_ranges_have_pids = last_supported_pid > end_pid
 
         pids_to_encode = supported.copy()
-        if next_range_has_pids:
+        if next_ranges_have_pids:
             pids_to_encode.append(end_pid - start_pid + 1)
-        
+
         relative_pids = [(pid - start_pid + 1) for pid in supported if start_pid <= pid <= end_pid]
-        
-        if next_range_has_pids:
+
+        if next_ranges_have_pids:
             relative_pids.append(32)
 
         bitmap = generate_pids_bitmap(relative_pids)
@@ -4558,19 +4569,19 @@ def generate_dynamic_pids_entries(scenario_dict, service="01"):
             "Descr": f"Supported PIDS_{suffix} [{start_pid:02X}-{end_pid:02X}]",
             "Response": HD(ECU_R_ADDR_E) + SZ("06") + DT(f"41 {request_pid:02X} {bitmap}")
         }
-        
+
         # Special handling for PIDS_A to simulate "SEARCHING..."
         if suffix == 'A':
             pids_entries[entry_name]["ResponseHeader"] = \
                 lambda self, cmd, pid, uc_val: \
                     "<string>SEARCHING...</string>" \
                     "<exec>time.sleep(1.5)</exec>" + ST('') \
                         if self.counters[pid] == 1 else ''
-    
+
     return pids_entries
 
 
-def update_scenario_with_dynamic_pids(scenario_dict, service="01"):
+def update_scenario_with_dynamic_pids(scenario_dict: Dict[str, Dict[str, Any]], service: str = "01"):
     """
     Update a scenario dictionary with dynamically generated ELM_PIDS_X entries.
     This will replace existing static PIDS_ & ELM_PIDS_ entries with dynamic ones.
@@ -4583,7 +4594,7 @@ def update_scenario_with_dynamic_pids(scenario_dict, service="01"):
     pids_keys_to_remove = [k for k in scenario_dict.keys() if k.startswith(("ELM_PIDS_", "PIDS_"))]
     for key in pids_keys_to_remove:
         del scenario_dict[key]
-    
+
     # add new dynamic
     dynamic_pids = generate_dynamic_pids_entries(scenario_dict, service)
     scenario_dict.update(dynamic_pids)