Milestone 0.4 - minor update to 0.4.1 (#90)

* fix scope trigger and enumeration type (#87)

* removed MCU data width scaling, trigger point calculation for array element
* reinserting get_variable_raw
   This method was refactored in version 0.1 to internal method _get_variable_instance.
   VariableInfo was moved from Parser class to Variable class.
   The example SFR_Example.py was made to test this behavior but was not included into the tests. It is not yet included.
* refactored some examples to fix logging
* fix SFR example to import the right library
* change get_device_id example
* Fixed enum variable types (static only) inside structures still not working
* Enhancing enum implementation with architecture considerations (data width)
* fixed import error on LNet the code was importing the module and should import the class.

---------
Co-authored-by: Edras Pacola <edras.pacola@microchip.com>

* bump version to 0.4.1.

---------
Co-authored-by: X2Cscope <73351552+X2Cscope@users.noreply.github.com>

Author: MarkWendler

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "pyx2cscope"
-version = "0.4.0"
+version = "0.4.1"
 description = "python implementation of X2Cscope"
 authors = [
   "Yash Agarwal <yash.agarwal@microchip.com>",

pyx2cscope/__init__.py

@@ -1,11 +1,11 @@
 """This module contains the pyx2cscope package.
 
-Version: 0.4.0
+Version: 0.4.1
 """
 
 import logging
 
-__version__ = "0.4.0"
+__version__ = "0.4.1"
 
 
 def set_logger(

pyx2cscope/examples/SFR_Example.py

@@ -5,6 +5,7 @@
 
 from pyx2cscope.utils import get_com_port, get_elf_file_path
 from pyx2cscope.x2cscope import X2CScope
+from variable.variable import VariableInfo
 
 # Configuration for serial port communication
 serial_port = get_com_port()  # Select COM port
@@ -37,7 +38,7 @@ def set_led_state(value, bit_position, state):
     return value
 
 
-def sethigh(value, bit_position):
+def set_high(value, bit_position):
     """Set a specific bit to high (1).
 
     Args:
@@ -50,7 +51,7 @@ def sethigh(value, bit_position):
     return set_led_state(value, bit_position, True)
 
 
-def setlow(value, bit_position):
+def set_low(value, bit_position):
     """Set a specific bit to low (0).
 
     Args:
@@ -67,9 +68,8 @@ def example():
     """Main function to demonstrate LED state changes using SFR."""
     try:
         # Initialize the variable for the Special Function Register (SFR) controlling the LEDs
-        sfr_led = x2cscope.get_variable_raw(
-            3702, "int", "sfr"
-        )  # LATE address from data sheet 3702
+        variable_info = VariableInfo("my_led", "int", 1, 3702, 0, {})
+        sfr_led = x2cscope.get_variable_raw(variable_info) # LATE address from data sheet 3702
 
         # Get the initial LED state from the SFR
         initial_led_state = sfr_led.get_value()
@@ -79,23 +79,23 @@ def example():
             #########################
             # SET LED1 and LED2 High
             ##########################
-            led1_high_value = sethigh(initial_led_state, LED1_BIT)
+            led1_high_value = set_high(initial_led_state, LED1_BIT)
             sfr_led.set_value(led1_high_value)
 
             initial_led_state = sfr_led.get_value()
-            led2_high_value = sethigh(initial_led_state, LED2_BIT)
+            led2_high_value = set_high(initial_led_state, LED2_BIT)
             sfr_led.set_value(led2_high_value)
 
             #########################
             # SET LED1 and LED2 LOW
             ##########################
             time.sleep(1)
             initial_led_state = sfr_led.get_value()
-            led1_low_value = setlow(initial_led_state, LED1_BIT)
+            led1_low_value = set_low(initial_led_state, LED1_BIT)
             sfr_led.set_value(led1_low_value)
 
             initial_led_state = sfr_led.get_value()
-            led2_low_value = setlow(initial_led_state, LED2_BIT)
+            led2_low_value = set_low(initial_led_state, LED2_BIT)
             sfr_led.set_value(led2_low_value)
             time.sleep(1)
 

pyx2cscope/examples/demo.py

@@ -12,6 +12,7 @@
 x2cscope.add_scope_channel(phase_voltage)
 
 x2cscope.request_scope_data()
+
 while(1):
     if x2cscope.is_scope_data_ready():
         print(x2cscope.get_scope_channel_data())

pyx2cscope/examples/exampleMCAF.py

@@ -1,21 +1,13 @@
 """exampleMCAF.py.
 
-this example is the very basic example to retrieve the value of a certain variable for motorBench generated code.
+this example is a basic example to retrieve the value of a variable from motorBench auto-generated code.
 """
 
-import logging
-
 from pyx2cscope.utils import get_com_port, get_elf_file_path
 from pyx2cscope.x2cscope import X2CScope
 
-# Configure logging settings to capture all levels of log messages and write them to a file
-logging.basicConfig(
-    level=0,  # Log all levels of messages
-    filename="BlinkyMCFG.log",  # Log file name
-)
-
 # Configuration for serial port communication
-serial_port = get_com_port()  # Get the COM port to use from the utility function
+serial_port = get_com_port()  # Get the COM port from the utility function
 baud_rate = 115200  # Set baud rate for serial communication
 
 # Specify the path to the ELF file
@@ -35,13 +27,8 @@
 
 # Attempt to read the value of the 'speedReference' variable and log the result
 try:
-    speed_reference_value = (
-        speed_reference.get_value()
-    )  # Read the value of the speed reference variable
-    logging.debug(
-        f"Speed Reference Value: {speed_reference_value}"
-    )  # Log the retrieved value
+    # Read the value of the speed reference variable
+    speed_reference_value = speed_reference.get_value()
+    print(f"Speed Reference Value: {speed_reference_value}")
 except Exception as e:
-    logging.debug(
-        f"Error reading speed reference value: {e}"
-    )  # Log any exceptions that occur
+    print(f"Error reading speed reference value: {e}")

pyx2cscope/examples/get_device_id.py

@@ -0,0 +1,47 @@
+"""The simplest usage of the pyX2Cscope library without using and elf_file on the constructor.
+
+The script initializes the X2CScope class with a specified serial port without ELF file.
+At this way, we don't know which variables are available on the processor, but we can
+get connection info, processor id, and x2cscope version.
+
+It is possible to import later and elf file or a variable import file as .yml/.pkl
+In this way you can read variables available at flashed programm. Or use the method
+x2c_scope.get_variable_raw(VariableInfo var_info) to retrieve variables directly from the
+device's memory.
+"""
+
+from pyx2cscope.x2cscope import X2CScope
+from variable.variable import VariableInfo
+
+# initialize the X2CScope class with serial port, by default baud rate is 115200
+x2c_scope = X2CScope(port="COM32")
+
+# Read device_info
+device_info = x2c_scope.get_device_info()
+
+# Print the controller info
+# i.e.: {
+#   'processor_id': '__GENERIC_MICROCHIP_PIC32__',
+#   'uc_width': '32-bit',
+#   'date': 'Mar 32019',
+#   'time': '1220',
+#   'AppVer': 1,
+#   'dsp_state': 'Application runs on target'
+#   }
+print(device_info)
+
+# set the elf_file later, post instantiation to get some variables
+x2c_scope.import_variables("""your_path_to_elf_file.elf""")
+
+# Collect some variables, i.e.: from QSPIN on SAME54 MCLV-48V-300W
+angle_reference = x2c_scope.get_variable("mcFocI_ModuleData_gds.dOutput.elecAngle")
+speed_measured = x2c_scope.get_variable("mcFocI_ModuleData_gds.dOutput.elecSpeed")
+
+# or load a variable directly from the memory
+speed_measured_info = VariableInfo("speed_measured", "float", 2, 536879832, 0, {})
+speed_measured_raw = x2c_scope.get_variable_raw(speed_measured_info)
+
+# Read the value of the "motor.apiData.velocityMeasured" variable from the target
+print(speed_measured.get_value())
+
+

pyx2cscope/parser/elf_parser.py

@@ -8,29 +8,9 @@
 """
 from abc import ABC, abstractmethod
 
-from dataclasses import dataclass
 from typing import Dict, List, Optional
 
-
-@dataclass
-class VariableInfo:
-    """A data class representing information about a variable in an ELF file.
-
-    Attributes:
-        name (str): The name of the variable.
-        type (str): The data type of the variable.
-        byte_size (int): The size of the variable in bytes.
-        address (int): The memory address of the variable.
-        array_size (int): The size of the array if the variable is an array, default is 0.
-    """
-
-    name: str
-    type: str
-    byte_size: int
-    address: int
-    array_size: int
-    valid_values: Dict[str, int]
-
+from pyx2cscope.variable.variable import VariableInfo
 
 class ElfParser(ABC):
     """Abstract base class for parsing ELF files.

pyx2cscope/parser/generic_parser.py

@@ -75,15 +75,14 @@ def _get_die_variable_details(self, die_variable):
         # variables, so this step may be avoided here.
         # We let the code here in case we want to process them anyway.
         # elif (
-        #     die_variable.attributes.get("DW_AT_external")
-        #     and die_variable.attributes.get("DW_AT_name") is not None
-        # ):
-        #     return # Skipping external variables.  YA
-        #     self.var_name = die_variable.attributes.get("DW_AT_name").value.decode(
-        #         "utf-8"
-        #     )
-        #     self.die_variable = die_variable
-        #     self._extract_address(die_variable)
+        #      die_variable.attributes.get("DW_AT_external")
+        #      and die_variable.attributes.get("DW_AT_name") is not None
+        #  ):
+        #      self.var_name = die_variable.attributes.get("DW_AT_name").value.decode(
+        #          "utf-8"
+        #      )
+        #      self.die_variable = die_variable
+        #      self._extract_address(die_variable)
         else:
             return
 
@@ -397,7 +396,7 @@ def _get_structure_members_recursive(self, die, parent_name: str, prev_offset=0)
                 if name_attr:
                     member_name += "." + name_attr.value.decode("utf-8")
                 self._process_structure_member(member, child_die, prev_offset, offset, member_name)
-                members.update(member)
+                members.update(member) # member should be varinfo?
         return members, prev_offset
 
     def _get_structure_members(self, structure_die, var_name):

pyx2cscope/variable/variable.py

@@ -15,23 +15,46 @@
     - VariableInt64: Represents a 64-bit signed integer variable.
     - VariableUint64: Represents a 64-bit unsigned integer variable.
     - VariableFloat: Represents a floating-point number variable.
+    - VariableEnum: Represents an enum variable.
 
 """
 
 import logging
 import struct
 from abc import abstractmethod
+from dataclasses import dataclass
 from numbers import Number
-from typing import List
+from typing import List, Dict
 
-from mchplnet import lnet
+from mchplnet.lnet import LNet
+
+
+@dataclass
+class VariableInfo:
+    """A raw representation about a variable.
+
+    Attributes:
+        name (str): The name of the variable.
+        type (str): The data type of the variable.
+        byte_size (int): The size of the variable in bytes.
+        address (int): The memory address of the variable.
+        array_size (int): The size of the array if the variable is an array, default is 0.
+        valid_values (dict): enum type of valid values
+    """
+
+    name: str
+    type: str
+    byte_size: int
+    address: int
+    array_size: int
+    valid_values: Dict[str, int]
 
 
 class Variable:
     """Represents a variable in the MCU data memory."""
 
     def __init__(
-        self, l_net: lnet, address: int, array_size: int, name: str = None
+        self, l_net: LNet, address: int, array_size: int, name: str = None
     ) -> None:
         """Initialize the Variable object.
 
@@ -869,3 +892,94 @@ def bytes_to_value(self, data: bytearray) -> Number:
         """
         data = bytearray(data)
         return struct.unpack("<f", data)[0]
+
+
+# ------------------------------ Enum 2bytes ------------------------------
+class VariableEnum(Variable):
+    """Represents enum variable in the MCU data memory."""
+
+    def __init__(self, l_net: LNet, address: int, array_size: int, name: str,
+                 enum_list: dict[str, int]):
+        """Initialize the Variable object. But needs customised constructor due to enum list initialisation.
+
+        Args:
+            l_net (LNet): LNet protocol that handles the communication with the target device.
+            address (int): Address of the variable in the MCU memory.
+            array_size (int): The number of elements in the array, 0 in case of a plain variable.
+            name (str, optional): Name of the variable. Defaults to None.
+            enum_list (dict[str, int]): The enumeration list with the values.
+        """
+        super().__init__(l_net, address, array_size, name)
+        self.enum_list = enum_list       
+
+    def _get_min_max_values(self) -> tuple[Number, Number]:
+        """Get the minimum and maximum values for the 16-bit enum.
+
+        Returns:
+            tuple[Number, Number]: The minimum and maximum values.
+        """
+        return min(self.enum_list.values()), max(self.enum_list.values())
+
+    def is_integer(self) -> bool:
+        """Check if the variable is an integer.
+
+        Returns:
+            bool: Enumeration is stricktly an integer.
+        """
+        return True
+
+    def is_signed(self) -> bool:
+        """Check if the variable is signed.
+
+        Returns:
+            bool: Depending on the enum values.
+        """
+        if min(self.enum_list.values()) < 0:
+            return True
+        else:
+            return False
+
+    def get_width(self) -> int:
+        """Get the width of the 16-bit enum.
+
+        Returns:
+            int: Width of the variable, which is 2.
+        """
+        #TODO depends on architecture and enum count of elements
+        return self.l_net.device_info.uc_width
+ 
+
+    def set_value(self, value: int):
+        """Set the value of the 16-bit enum.
+
+        Args:
+            value (int): The value to set.
+        """
+        try:
+            self._check_value_range(value) #TODO might be different than super class
+            int_value = int(value)
+            bytes_data = int_value.to_bytes(
+                length=self.l_net.device_info.uc_width, byteorder="little", signed=self.is_signed()
+            )  # construct the bytes representation of the value
+            self._set_value_raw(bytes_data)
+        except Exception as e:
+            logging.error(e)
+
+    def bytes_to_value(self, data: bytearray) -> Number:
+        """Convert the byte array to enum.
+
+        Args:
+            data (bytearray): The byte array to convert.
+
+        Returns:
+            Number: The enum value.
+        """
+        return int.from_bytes(data, "little", signed=self.is_signed())
+
+    def get_enumerator_list(self) -> Dict[str, int]:
+        """Get the valid values for the enum variable.
+
+        Returns:
+            Dict[str, int]: A dictionary of valid values for the enum variable.
+        """
+        return self.enum_list