lwl now supports strings as function ids

Author: Manwlis

README.md

@@ -171,12 +171,12 @@ lwl_enter_record(
 ```
 
 #### IDs
-`MODULE_ID` and `FUNCTION_ID` must be macros defined in `lwl.h` and must be single byte values. Preferably single character literals to improve readability of the logs.
+`MODULE_ID` and `FUNCTION_ID` must be macros defined in `lwl.h`. `MODULE_ID` must be a single byte values, preferably single character literal to improve readability of the logs. `FUNCTION_ID` can be any string.
 
 Example:
 ```c
 #define LIS3DHTR_LWL_ID      'L'
-#define LIS3DHTR_READ_LWL_ID 'R'
+#define LIS3DHTR_READ_LWL_ID "RX"
 ```
 
 The `( MODULE_ID, FUNCTION_ID )` combination must be globally unique across the project.

code/CM7/Core/Src/adc.c

@@ -257,7 +257,7 @@ HAL_StatusTypeDef calc_ADC_temp_reduced_div( int64_t* const result )
 
 HAL_StatusTypeDef calc_ADC_temp_int( int64_t* const result )
 {
-	lwl_enter_record( ADC_LWL_ID , ADC_REDUCED_DIV_LWL_ID , "" );
+	lwl_enter_record( ADC_LWL_ID , ADC_INT_LWL_ID , "" );
 
 	// No adc readings yet
 	if( latest_adc_buf == NULL )
@@ -284,7 +284,7 @@ HAL_StatusTypeDef calc_ADC_temp_int( int64_t* const result )
 
 HAL_StatusTypeDef calc_ADC_temp_float( float* const result )
 {
-	lwl_enter_record( ADC_LWL_ID , ADC_INT_LWL_ID , "" );
+	lwl_enter_record( ADC_LWL_ID , ADC_FLOAT_LWL_ID , "" );
 
 	// No adc readings yet
 	if( latest_adc_buf == NULL )

code/CM7/Core/lwl/lwl.c

@@ -45,7 +45,7 @@ void lwl_init()
 	lwl_driver.is_initialized = true;
 }
 
-void lwl_enter_record( uint8_t module_id , uint8_t functionality_id , const char* fmt , ... )
+void lwl_enter_record( uint8_t module_id , char functionality_id[] , const char* fmt , ... )
 {
 	if( lwl_driver.is_initialized == false )
 		return;
@@ -55,8 +55,11 @@ void lwl_enter_record( uint8_t module_id , uint8_t functionality_id , const char
 //	If buffer size is not power of 2 then
 //  lwl_data.next_entry_index = (lwl_data.next_entry_index + 1) % LWL_BUFFER_SIZE;
 
-	lwl_data.buffer[lwl_data.next_entry_index] = functionality_id;
-	lwl_data.next_entry_index = ( lwl_data.next_entry_index + 1 ) & ( LWL_BUFFER_SIZE - 1 );
+	for( int i = 0 ; functionality_id[i] != '\0' ; i++)
+	{
+		lwl_data.buffer[lwl_data.next_entry_index] = (uint8_t)(functionality_id[i]);
+		lwl_data.next_entry_index = ( lwl_data.next_entry_index + 1 ) & ( LWL_BUFFER_SIZE - 1 );
+	}
 
 	va_list args;
 

code/CM7/Core/lwl/lwl.h

@@ -13,29 +13,29 @@
 
 /* Macros ------------------------------------------------------------------*/
 #define LIS3DHTR_LWL_ID 'L'
-#define LIS3DHTR_WRITE_LWL_ID 'W'
-#define LIS3DHTR_READ_LWL_ID 'R'
+#define LIS3DHTR_WRITE_LWL_ID "W"
+#define LIS3DHTR_READ_LWL_ID "R"
 
 #define ADC_LWL_ID 'A'
-#define ADC_REDUCED_DIV_LWL_ID 'R'
-#define ADC_INT_LWL_ID 'I'
-#define ADC_FLOAT_LWL_ID 'F'
+#define ADC_REDUCED_DIV_LWL_ID "R"
+#define ADC_INT_LWL_ID "I"
+#define ADC_FLOAT_LWL_ID "F"
 
 #define TEST_LWL_ID 'T'
-#define TEST_TEST_LWL_ID 'T'
+#define TEST_TEST_LWL_ID "TEST"
 
 #define I2C_LWL_ID 'I'
-#define I2C_TX_IT_LWL_ID 'T'
-#define I2C_RX_IT_LWL_ID 'R'
-#define I2C_ER_IT_LWL_ID 'E'
+#define I2C_TX_IT_LWL_ID "TX"
+#define I2C_RX_IT_LWL_ID "RX"
+#define I2C_ER_IT_LWL_ID "ER"
 
 #define SPI_LWL_ID 'S'
-#define SPI_RX_IT_LWL_ID 'R'
-#define SPI_ER_IT_LWL_ID 'E'
+#define SPI_RX_IT_LWL_ID "RX"
+#define SPI_ER_IT_LWL_ID "TX"
 
 /* Exported functions prototypes ---------------------------------------------*/
 void lwl_init();
-void lwl_enter_record( uint8_t module_id , uint8_t functionality_id , const char* fmt , ... );
+void lwl_enter_record( uint8_t module_id , char functionality_id[] , const char* fmt , ... );
 void dump_log();
 
 #endif /* LWL_LWL_H_ */

code/CM7/sensor_playground_CM7 Debug.launch

@@ -85,6 +85,6 @@
     <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
         <listEntry value="4"/>
     </listAttribute>
-    <stringAttribute key="org.eclipse.dsf.launch.MEMORY_BLOCKS" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&lt;memoryBlockExpressionList context=&quot;reserved-for-future-use&quot;&gt;&lt;gdbmemoryBlockExpression address=&quot;603980424&quot; label=&quot;lwl_data.buffer&quot;/&gt;&lt;/memoryBlockExpressionList&gt;"/>
+    <stringAttribute key="org.eclipse.dsf.launch.MEMORY_BLOCKS" value="&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&lt;memoryBlockExpressionList context=&quot;reserved-for-future-use&quot;&gt;&lt;gdbmemoryBlockExpression address=&quot;603980968&quot; label=&quot;lwl_data.buffer&quot;/&gt;&lt;/memoryBlockExpressionList&gt;"/>
     <stringAttribute key="process_factory_id" value="com.st.stm32cube.ide.mcu.debug.launch.HardwareDebugProcessFactory"/>
 </launchConfiguration>

lwl_decoder.py

@@ -11,7 +11,7 @@
 
 
 ROOT_DIR = "."
-DUMP_BIN = "./code/debug/test3/dump.bin"
+DUMP_BIN = "./code/debug/test5/dump.bin"
 INFO_PATH = Path(DUMP_BIN).parent / "info.txt"
 LWL_DEFINES_FILE = "./code/CM7/Core/lwl/lwl.h"
 
@@ -36,7 +36,7 @@
 CALL_START = re.compile(r'\blwl_enter_record\s*\(')
 
 DEFINE_REGEX = re.compile(
-    r'^\s*#define\s+(\w+)\s+\'(.)\'',
+    r'^\s*#define\s+(\w+)\s+(.+)$',
     re.MULTILINE
 )
 
@@ -60,13 +60,24 @@ def clean_code(text):
 
 def parse_defines(filepath):
 
-    with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
+    defines = {}
+
+    with open(filepath,'r',encoding='utf-8',errors='ignore') as f:
         content = f.read()
 
-    defines = {}
+    for name,value in DEFINE_REGEX.findall(content):
+
+        value = value.strip()
 
-    for name, value in DEFINE_REGEX.findall(content):
-        defines[name] = ord(value)
+        # char literal
+        if value.startswith("'") and value.endswith("'"):
+
+            defines[name] = eval(value)
+
+        # string literal
+        elif value.startswith('"') and value.endswith('"'):
+
+            defines[name] = value[1:-1]
 
     return defines
 
@@ -174,9 +185,13 @@ def extract_calls(text):
     return matches
 
 
-def calculate_size(args):
+def calculate_size(args, id_defines):
+
+    size = 1      # module char
 
-    size = 2
+    function_str = id_defines[args[1]]
+
+    size += len(function_str)
 
     if len(args) < 3:
         return size
@@ -237,7 +252,7 @@ def build_call_database():
 
             entry = {
                 "args": args,
-                "size": calculate_size(args),
+                "size": calculate_size(args , id_defines),
                 "key": resolved_key
             }
 
@@ -354,19 +369,40 @@ def try_decode(decoded_buffer, decoder_table):
 
     while offset < len(decoded_buffer):
 
-        if offset + 2 > len(decoded_buffer):
+        if offset + 1 > len(decoded_buffer):
             return False, decoded_entries, offset
 
-        key = (
-            decoded_buffer[offset],
-            decoded_buffer[offset+1]
-        )
+        module_char = chr(decoded_buffer[offset])
+
+        matched_entry = None
+        best_len = -1
+
+        for entry in decoder_table.values():
+
+            entry_module, entry_function = entry["key"]
+
+            if entry_module != module_char:
+                continue
+
+            function_bytes = entry_function.encode()
 
-        if key not in decoder_table:
+            start = offset + 1
+            end = start + len(function_bytes)
+
+            if end > len(decoded_buffer):
+                continue
+
+            if decoded_buffer[start:end] == function_bytes:
+
+                if len(function_bytes) > best_len:
+
+                    matched_entry = entry
+                    best_len = len(function_bytes)
+
+        if matched_entry is None:
             return False, decoded_entries, offset
 
-        entry = decoder_table[key]
-        size = entry["size"]
+        size = matched_entry["size"]
 
         if offset + size > len(decoded_buffer):
             return False, decoded_entries, offset
@@ -460,32 +496,58 @@ def decode_buffer(decoded_buffer, decoder_table, decode_point):
 
     while offset < len(decoded_buffer):
 
-        if offset + 2 > len(decoded_buffer):
+        if offset + 1 > len(decoded_buffer):
+
             print(
-                f"ERROR: truncated entry header "
-                f"at offset {offset}"
+                f"ERROR: truncated module ID "
+                f"at byte {decode_point + offset}"
             )
             return
 
-        key = (
-            decoded_buffer[offset],
-            decoded_buffer[offset+1]
-        )
+        module_char = chr(decoded_buffer[offset])
+
+        matched_entry = None
+        best_len = -1
+
+        for entry in decoder_table.values():
+
+            entry_module, entry_function = entry["key"]
 
-        if key not in decoder_table:
+            if entry_module != module_char:
+                continue
+
+            function_bytes = entry_function.encode()
+
+            start = offset + 1
+            end = start + len(function_bytes)
+
+            if end > len(decoded_buffer):
+                continue
+
+            if decoded_buffer[start:end] == function_bytes:
+
+                if len(function_bytes) > best_len:
+
+                    matched_entry = entry
+                    best_len = len(function_bytes)
+
+        if matched_entry is None:
 
             print(
                 f"ERROR: unknown entry "
-                f"{chr(key[0])}{chr(key[1])} "
-                f"at byte {decode_point + offset}"
+                f"at byte {decode_point + offset} "
+                f"(module='{module_char}')"
             )
 
-            return
+            print(
+                f"DEBUG offset={offset} "
+                f"bytes={decoded_buffer[offset:offset+15]}"
+            )
 
-        entry = decoder_table[key]
+            return
 
-        args = entry["args"]
-        size = entry["size"]
+        args = matched_entry["args"]
+        size = matched_entry["size"]
 
         if offset + size > len(decoded_buffer):
 
@@ -496,62 +558,91 @@ def decode_buffer(decoded_buffer, decoder_table, decode_point):
 
             return
 
+        module_id, function_id = matched_entry["key"]
+
+        function_bytes = function_id.encode()
+
         fmt = args[2][1:-1]
 
-        pos = offset + 2
+        pos = (
+            offset
+            + 1
+            + len(function_bytes)
+        )
+
+        module_str = (
+            f"{args[0]} ({module_id})"
+        )
 
-        module_str = f"{args[0]} ({chr(key[0])})"
-        function_str = f"{args[1]} ({chr(key[1])})"
+        function_str = (
+            f'{args[1]} ("{function_id}")'
+        )
 
         arg_output = []
 
         for fmt_char, name in zip(fmt, args[3:]):
 
             if fmt_char == 'c':
+
                 value = decoded_buffer[pos]
                 pos += 1
 
             elif fmt_char == 's':
+
                 value = int.from_bytes(
                     decoded_buffer[pos:pos+2],
                     'little',
                     signed=True
                 )
+
                 pos += 2
 
             elif fmt_char == 'h':
+
                 value = int.from_bytes(
                     decoded_buffer[pos:pos+2],
                     'little',
                     signed=False
                 )
+
                 pos += 2
 
             elif fmt_char == 'd':
+
                 value = int.from_bytes(
                     decoded_buffer[pos:pos+4],
                     'little',
                     signed=True
                 )
+
                 pos += 4
 
             elif fmt_char == 'u':
+
                 value = int.from_bytes(
                     decoded_buffer[pos:pos+4],
                     'little',
                     signed=False
                 )
+
                 pos += 4
 
             elif fmt_char == 'f':
+
                 value = struct.unpack(
                     '<f',
                     decoded_buffer[pos:pos+4]
                 )[0]
+
                 pos += 4
 
             else:
-                print(f"ERROR: unknown format '{fmt_char}'")
+
+                print(
+                    f"ERROR: unknown format "
+                    f"'{fmt_char}'"
+                )
+
                 return
 
             arg_output.append(