pytest-embedded-nuttx 1.11.8__py3-none-any.whl

pytest_embedded_nuttx/__init__.py

@@ -0,0 +1,23 @@
+"""Make pytest-embedded plugin work with NuttX."""
+
+import importlib
+
+from pytest_embedded.utils import lazy_load
+
+from .dut import NuttxDut, NuttxEspDut
+
+__getattr__ = lazy_load(
+    importlib.import_module(__name__),
+    {
+        'NuttxDut': NuttxDut,
+        'NuttxEspDut': NuttxEspDut,  # requires 'esp' service
+    },
+    {
+        'NuttxApp': '.app',  # requires 'esp' service
+        'NuttxSerial': '.serial',  # requires 'esp' service
+    },
+)
+
+__all__ = ['NuttxApp', 'NuttxSerial', 'NuttxEspDut', 'NuttxDut']
+
+__version__ = '1.11.8'

pytest_embedded_nuttx/app.py

@@ -0,0 +1,100 @@
+import logging
+from pathlib import Path
+
+from esptool.cmds import FLASH_MODES, LoadFirmwareImage
+from pytest_embedded.app import App
+
+
+class NuttxApp(App):
+    """
+    NuttX App class for Espressif devices.
+    Evaluates binary files (firmware and bootloader) and extract information
+    required for flashing.
+
+    Attributes:
+        file_extension (str): app binary file extension.
+    """
+
+    def __init__(
+        self,
+        file_extension='.bin',
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        self.flash_size = None
+        self.flash_freq = None
+        self.flash_mode = None
+        self.file_extension = file_extension
+        files = self._get_bin_files()
+        self.app_file, self.bootloader_file, self.merge_file = files
+        self._get_binary_target_info()
+
+    def _get_bin_files(self) -> list:
+        """
+        Get path to binary files available in the app_path.
+        If either the application image or bootloader is not found,
+        None is returned.
+
+        Returns:
+            list: path to application binary file and bootloader file.
+        """
+        search_path = Path(self.app_path)
+        search_pattern = '*' + self.file_extension
+        bin_files = list(search_path.rglob(search_pattern))
+        app_file, bootloader_file, merge_file = None, None, None
+
+        logging.info('Searching %s', str(search_path))
+        if not bin_files:
+            logging.warning('No binary files found with pattern: %s', search_pattern)
+
+        for file_path in bin_files:
+            file_name = str(file_path.stem)
+            if 'nuttx' in file_name:
+                if 'merged' in file_name:
+                    merge_file = file_path
+                else:
+                    app_file = file_path
+            if 'mcuboot-' in file_name:
+                bootloader_file = file_path
+
+        if not app_file:
+            logging.error('App file not found: %s', app_file)
+            print(bin_files)
+
+        return app_file, bootloader_file, merge_file
+
+    def _get_binary_target_info(self):
+        """Binary target should be in the format nuttx.merged.bin, where
+        the 'merged.bin' extension can be modified by the file_extension
+        argument.
+
+        Important note regarding MCUBoot:
+        If enabled, the magic number will be on the MCUBoot binary. In this
+        case, image_info should run on the mcuboot binary, not the NuttX one.
+        """
+
+        def get_key_from_value(dictionary, val):
+            """Get key from value in dictionary"""
+            for key, value in dictionary.items():
+                if value == val:
+                    return key
+            return None
+
+        binary_path = self.app_file
+        if self.bootloader_file:
+            binary_path = self.bootloader_file
+
+        # Load app image and retrieve flash information
+        image = LoadFirmwareImage(self.target, binary_path.as_posix())
+
+        # Flash Size
+        flash_s_bits = image.flash_size_freq & 0xF0
+        self.flash_size = get_key_from_value(image.ROM_LOADER.FLASH_SIZES, flash_s_bits)
+
+        # Flash Frequency
+        flash_fr_bits = image.flash_size_freq & 0x0F  # low four bits
+        self.flash_freq = get_key_from_value(image.ROM_LOADER.FLASH_FREQUENCY, flash_fr_bits)
+
+        # Flash Mode
+        self.flash_mode = get_key_from_value(FLASH_MODES, image.flash_mode)

pytest_embedded_nuttx/dut.py

@@ -0,0 +1,106 @@
+import logging
+import re
+from time import sleep
+from typing import TYPE_CHECKING, AnyStr
+
+import pexpect
+from pytest_embedded_serial.dut import SerialDut
+
+if TYPE_CHECKING:
+    from .app import NuttxApp
+
+
+class NuttxDut(SerialDut):
+    """
+    Generic DUT class for use with NuttX RTOS.
+    """
+
+    PROMPT_NSH = 'nsh>'
+    PROMPT_TIMEOUT_S = 30
+
+    def __init__(
+        self,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+
+    def write(self, data: str) -> None:
+        """
+        Write to NuttShell and sleep for a few hundred milliseconds to
+        ensure there is time for Nuttshell prompt appear again.
+
+        Args:
+            data (str): data to be passed on to Nuttshell.
+
+        Returns:
+            None.
+        """
+        super().write('')
+        self.expect(self.PROMPT_NSH, timeout=self.PROMPT_TIMEOUT_S)
+        super().write(data)
+        sleep(0.25)
+
+    def return_code(self, timeout: int = PROMPT_TIMEOUT_S) -> int:
+        """
+        Matches the 'echo $?' response and extracts the integer value
+        corresponding to the last program return code.
+
+        Returns:
+            int: return code.
+        """
+        self.write('echo $?')
+        echo_match = self.expect(r'echo \$\?\r\n(\d+)', timeout=timeout)
+        ret_code = re.findall(r'\d+', echo_match.group().decode())
+
+        if not ret_code:
+            logging.error('Failed to retrieve return code')
+
+        return int(ret_code[0])
+
+    def write_and_return(self, data: str, timeout: int = 2) -> AnyStr:
+        """
+        Writes to Nuttshell and returns all available serial data until
+        the timeout.
+        This is useful when parsing and reusing the data is required, and
+        pexect is not enough.
+
+        Args:
+            data (str): data to be passed on to Nuttshell.
+            timeout (int): how long to wait for an answer in seconds.
+
+        Returns:
+            AnyStr
+        """
+        self.write(data)
+        ans = self.expect(pexpect.TIMEOUT, timeout=timeout)
+        return ans.rstrip().decode()
+
+
+class NuttxEspDut(NuttxDut):
+    """
+    DUT class for serial ports connected to Espressif boards which are
+    flashed with NuttX RTOS.
+    """
+
+    def __init__(
+        self,
+        app: 'NuttxApp',
+        **kwargs,
+    ) -> None:
+        self.target = app.target
+
+        super().__init__(app=app, **kwargs)
+
+    def reset_to_nsh(self, ready_prompt: str = NuttxDut.PROMPT_NSH) -> None:
+        """
+        Resets the board and waits until the Nuttshell prompt appears.
+        Defaults to 'nsh>'.
+
+        Args:
+            ready_prompt (str): string on prompt that signals completion.
+
+        Returns:
+            None
+        """
+        self.serial.hard_reset()
+        self.expect(ready_prompt, timeout=NuttxDut.PROMPT_TIMEOUT_S)

pytest_embedded_nuttx/serial.py

@@ -0,0 +1,75 @@
+from typing import ClassVar, Dict, Optional
+
+import esptool
+from pytest_embedded_serial_esp.serial import EspSerial
+
+from .app import NuttxApp
+
+
+class NuttxSerial(EspSerial):
+    """
+    NuttX serial DUT class.
+    """
+
+    # Default offset for the primary MCUBoot slot across
+    # all Espressif devices on NuttX
+    MCUBOOT_PRIMARY_SLOT_OFFSET = 0x10000
+    FLASH_BAUDRATE = 921600
+    SERIAL_BAUDRATE = 115200
+
+    binary_offsets: ClassVar[Dict[str, int]] = {
+        'esp32': 0x1000,
+        'esp32s2': 0x1000,
+        'esp32c3': 0x0,
+        'esp32s3': 0x0,
+        'esp32c6': 0x0,
+        'esp32h2': 0x0,
+        'esp32p4': 0x2000,
+    }
+
+    def __init__(
+        self,
+        app: NuttxApp,
+        target: Optional[str] = None,
+        **kwargs,
+    ) -> None:
+        self.app = app
+        super().__init__(
+            target=target or self.app.target,
+            **kwargs,
+        )
+
+    @EspSerial.use_esptool()
+    def flash(self) -> None:
+        """Flash the binary files to the board."""
+
+        flash_files = []
+        if self.app.bootloader_file:
+            flash_files.extend((str(self.binary_offsets[self.target]), self.app.bootloader_file.as_posix()))
+            flash_files.extend((str(self.MCUBOOT_PRIMARY_SLOT_OFFSET), self.app.app_file.as_posix()))
+        else:
+            flash_files.extend((str(self.binary_offsets[self.target]), self.app.app_file.as_posix()))
+
+        flash_settings = [
+            '--flash_mode',
+            self.app.flash_mode,
+            '--flash_size',
+            self.app.flash_size,
+            '--flash_freq',
+            self.app.flash_freq,
+        ]
+
+        esptool.main(
+            [
+                '--chip',
+                self.app.target,
+                '--port',
+                self.port,
+                '--baud',
+                str(self.FLASH_BAUDRATE),
+                'write_flash',
+                *flash_files,
+                *flash_settings,
+            ],
+            esp=self.esp,
+        )

pytest_embedded_nuttx-1.11.8.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Espressif Systems (Shanghai) Co. Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pytest_embedded_nuttx-1.11.8.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 2.3
+Name: pytest-embedded-nuttx
+Version: 1.11.8
+Summary: Make pytest-embedded plugin work with NuttX.
+Author-email: Filipe Cavalcanti <filipe.cavalcanti@espressif.com>, Fu Hanxi <fuhanxi@espressif.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Testing
+Requires-Dist: pytest-embedded-serial~=1.11.8
+Requires-Dist: pytest-embedded-serial-esp~=1.11.8 ; extra == "esp"
+Project-URL: changelog, https://github.com/espressif/pytest-embedded/blob/main/CHANGELOG.md
+Project-URL: documentation, https://docs.espressif.com/projects/pytest-embedded/en/latest/
+Project-URL: homepage, https://github.com/espressif/pytest-embedded
+Project-URL: repository, https://github.com/espressif/pytest-embedded
+Provides-Extra: esp
+
+### pytest-embedded-nuttx
+
+Pytest embedded service for the NuttX project, compatible with Espressif devices.
+
+Using the 'nuttx' service alongside 'serial' enables reading from and writing to the serial port, taking NuttShell into account when running programs and retrieving return codes.
+
+The `nuttx` service provides basic serial communication and testing. Adding the 'esp' service enables further capabilities for Espressif devices, including flashing and device rebooting.
+
+Additional Features:
+
+- `app`: Scans the NuttX binary directory to locate firmware and bootloader files.
+- `serial`: Parses binary information and flashes the board. Requires the 'esp' service.
+- `dut`: Sends commands to the device through the serial port. Requires the 'serial' service or 'esp' service for Espressif devices.
+

pytest_embedded_nuttx-1.11.8.dist-info/RECORD

@@ -0,0 +1,8 @@
+pytest_embedded_nuttx/__init__.py,sha256=3Qk0lUQU0mlBMXDlRBfuOSZAVgEOFSrnS9txxXKCFBc,543
+pytest_embedded_nuttx/app.py,sha256=Ss7kbBv2jYjT3AvO7pMJQA1N_Bh90G5jge5oS81HZSU,3364
+pytest_embedded_nuttx/dut.py,sha256=3mI0fAUMBOntqbHBK_woWD4HSR8iPvrggQRmXAMPSmQ,2792
+pytest_embedded_nuttx/serial.py,sha256=7n9d1HLaJgOE7CXrcjrTPa61whOjy1_VzHc6vR3INe0,1981
+pytest_embedded_nuttx-1.11.8.dist-info/LICENSE,sha256=_Um-MzeKCR0JCDg5Ac_WFmZEfsPTd7PNlNi9JF1GBX8,1094
+pytest_embedded_nuttx-1.11.8.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+pytest_embedded_nuttx-1.11.8.dist-info/METADATA,sha256=PiPcY5_6FHCUU2PJ-5VAU9jpRqwbkw21vNi7IF4GwjI,2328
+pytest_embedded_nuttx-1.11.8.dist-info/RECORD,,

pytest_embedded_nuttx-1.11.8.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.10.1
+Root-Is-Purelib: true
+Tag: py3-none-any