aj090-hw-tools 0.0.4__tar.gz → 0.0.5__tar.gz

{aj090_hw_tools-0.0.4 → aj090_hw_tools-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aj090-hw-tools
-Version: 0.0.4
+Version: 0.0.5
 Project-URL: Documentation, https://github.com/Vasencheg/aj090-hw-tools#readme
 Project-URL: Issues, https://github.com/Vasencheg/aj090-hw-tools/issues
 Project-URL: Source, https://github.com/Vasencheg/aj090-hw-tools
@@ -22,7 +22,7 @@ Requires-Dist: aiofile>=3.9.0
 Requires-Dist: aiohttp>=3.11.14
 Requires-Dist: colorama>=0.4.6
 Requires-Dist: configargparse>=1.7
-Requires-Dist: esp-idf-nvs-partition-gen==0.1.8
+Requires-Dist: esp-idf-nvs-partition-gen>=0.1.8
 Requires-Dist: esptool==4.8.1
 Requires-Dist: numpy>=2.2.4
 Requires-Dist: pexpect>=4.9.0

{aj090_hw_tools-0.0.4 → aj090_hw_tools-0.0.5}/pyproject.toml

@@ -27,7 +27,7 @@ classifiers = [
 dependencies = [
   "pyserial>=3.5",
   "esptool==4.8.1",
-  "esp_idf_nvs_partition_gen==0.1.8",
+  "esp-idf-nvs-partition-gen>=0.1.8",
   "pexpect>=4.9.0",
   "configargparse>=1.7",
   "aiohttp>=3.11.14",

{aj090_hw_tools-0.0.4 → aj090_hw_tools-0.0.5}/src/aj090_hw_tools/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Vasencheg <roman.vasilev@nobitlost.com>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.0.4"
+__version__ = "0.0.5"

{aj090_hw_tools-0.0.4 → aj090_hw_tools-0.0.5}/src/aj090_hw_tools/__init__.py

@@ -5,7 +5,8 @@ from .__about__ import __version__
 from .tools import (
     firmware,
     test,
-    info
+    info,
+    serial
 )
 
 __all__ = [
@@ -36,11 +37,11 @@ def _main():
     parser_firmware = subparsers.add_parser('firmware', help='device firmware operations group')
     parser_firmware.set_defaults(func=firmware)
     parser_firmware.add_argument('operation', type=str, choices=['write', 'erase'], help='firmware operations')
-    parser_firmware.add_argument('--bin_file', type=str, help='firmware bin file')
+    parser_firmware.add_argument('-f', '--bin_file', type=str, help='firmware bin file')
 
     # Info
-    parser_firmware = subparsers.add_parser('info', help='device info')
-    parser_firmware.set_defaults(func=info)
+    parser_info = subparsers.add_parser('info', help='device info')
+    parser_info.set_defaults(func=info)
 
     # Test
     parser_test = subparsers.add_parser('test', help='device tests')
@@ -48,6 +49,9 @@ def _main():
 
     # Serial
     parser_serial = subparsers.add_parser('serial', help='device serial number operations')
+    parser_serial.set_defaults(func=serial)
+    parser_serial.add_argument('operation', type=str, choices=['write', 'read'], help='serial operations')
+    parser_serial.add_argument('-s', '--serial', type=str, required='write' in sys.argv, help='serial number')
 
     # Factory
     # parser_factory = subparsers.add_parser('factory_mode', help='device factory mode control')

aj090_hw_tools-0.0.5/src/aj090_hw_tools/common/const.py

@@ -0,0 +1 @@
+SERIAL_NUM_PATTERN = r'\d\d{2}\d{2}\d\d{4}'

{aj090_hw_tools-0.0.4 → aj090_hw_tools-0.0.5}/src/aj090_hw_tools/tools/info.py

@@ -4,6 +4,7 @@ import pexpect
 import pexpect.spawnbase
 import time
 import esptool
+import re
 
 from rich.console import Console
 from rich.table import Table
@@ -11,6 +12,8 @@ from pexpect.fdpexpect import fdspawn
 from typing import Optional, Type, NamedTuple
 from esptool.cmds import detect_chip
 
+from ..common.const import SERIAL_NUM_PATTERN
+
 __all__ = [
     'info'
 ]
@@ -40,7 +43,7 @@ class DeviceInfo(NamedTuple):
     sn: str
 
 async def board_type_get(dut: DUT) -> Optional[str]:
-    result = await dut.expect(['MAIN: Starting (?:\w+ )?(CELL|SHELF) CONTROLLER application', pexpect.TIMEOUT], timeout=5.0, async_=True)
+    result = await dut.expect([r'MAIN: Starting (?:\w+ )?(CELL|SHELF) CONTROLLER application', pexpect.TIMEOUT], timeout=5.0, async_=True)
     if result:
         raise GatherInfoError('Unknown type of board or device has not been flashed yet')
     board_type = dut.match.group(1).decode('utf-8').lower()
@@ -53,8 +56,10 @@ async def device_info_get(dut: DUT) -> Optional[DeviceInfo]:
     #     sha256: 3c050c5d0ea4aea33643eba2b7e840c607af710176e4387b3b22f183c920f09e
     #     hw version: 1.0
     #     MAC: 64:E8:33:48:EF:C4
-    #     serial: AJ090_SC_XX_XXXXXXXX
-    MATCH_PATTERN = 'DEVICE_INFO:\s+app version:\s+(\w{7})\s+compile time:\s+(\d{2}:\d{2}:\d{2})\s+sha256:\s+(\w{64})\s+hw version:\s+(\d{1}\.\d{1})\s+MAC:\s+(\w{2}:\w{2}:\w{2}:\w{2}:\w{2}:\w{2})\s+serial:\s+(AJ090_(?:SC|CC)_\w+)'
+    #     serial: XXXXXXXX
+    MATCH_PATTERN = re.compile(
+        r'DEVICE_INFO:\s+app version:\s+(\w{{7}})\s+compile time:\s+(\d{{2}}:\d{{2}}:\d{{2}})\s+sha256:\s+(\w{{64}})\s+hw version:\s+(\d{{1}}\.\d{{1}})\s+MAC:\s+(\w{{2}}:\w{{2}}:\w{{2}}:\w{{2}}:\w{{2}}:\w{{2}})\s+serial:\s+({SERIAL_NUM_PATTERN})'.format(SERIAL_NUM_PATTERN=SERIAL_NUM_PATTERN)
+    )
     result = await dut.expect([MATCH_PATTERN, pexpect.TIMEOUT], timeout=5.0, async_=True)
     if result:
         raise GatherInfoError('Failed to collect information about the device')

aj090_hw_tools-0.0.5/src/aj090_hw_tools/tools/serial_number.py

@@ -0,0 +1,98 @@
+import asyncio
+import logging
+import subprocess
+import sys
+import tempfile
+import re
+import esptool
+import time
+
+from esptool.cmds import detect_chip
+from rich.console import Console
+
+from ..common.const import SERIAL_NUM_PATTERN
+
+__all__ = [
+    'serial'
+]
+
+# Logger 
+FORMAT = '%(name)s:%(levelname)s: %(message)s'
+logging.basicConfig(level=logging.ERROR, format=FORMAT)
+logger = logging.getLogger(__name__)
+
+console = Console()
+
+def nvs_partition_template(factory_mode: bool, hw_version: str, serial_number: str) -> str:
+    return """key,type,encoding,value
+factory,namespace,,
+factory_mode,data,u8,{factory_mode}
+hw_version,data,string,{hw_version}
+serial,data,string,{serial_number}
+""".format(
+    factory_mode  = int(factory_mode),
+    hw_version    = hw_version,
+    serial_number = serial_number
+)
+
+async def nvs_write(device, bin_file: str, offset: int = 0x11000) -> None:
+    def _write():
+        command = ['write_flash', f'{offset}', f'{bin_file}']
+        logger.debug("Using command ", " ".join(command))
+        esptool.main(command, device)
+
+    loop = asyncio.get_running_loop()
+    return await loop.run_in_executor(None, _write) 
+
+async def serial_write(device, serial: str) -> int:
+    match = re.search(SERIAL_NUM_PATTERN, serial)
+    if match is None:
+        console.print('Wrong serial number format', style='bold red')
+        return -1
+    serial = match.group(0)
+    with tempfile.NamedTemporaryFile(suffix='.csv') as nvs_csv:
+        data = bytes(nvs_partition_template(True, '1.0', serial).encode())
+        nvs_csv.write(data)
+        nvs_csv.seek(0)
+        logger.debug(f'CSV file data: {nvs_csv.read()}')
+
+        with tempfile.NamedTemporaryFile(suffix='.bin') as nvs_bin:
+            args   = ['generate', nvs_csv.name, nvs_bin.name, '0x10000']
+            result = subprocess.run([sys.executable, '-m', 'esp_idf_nvs_partition_gen'] + args).returncode
+            if not result:
+                await nvs_write(device, nvs_bin.name)
+            else:
+                console.print('NVS partition generate error', style='bold red')
+                return -1
+    
+    console.print('SUCCESS', style='bold green')
+
+async def serial_read() -> int:
+    return -1
+
+def serial(argv) -> int:
+    port     = argv.port if argv.port is not None else esptool.ESPLoader.DEFAULT_PORT
+    connects = 10 # NOTE: the workaround to the issue "Could not open /dev/tty..., the port is busy or doesn't exist" 
+    for _ in range(connects): 
+        try:   
+            with detect_chip(port=port, connect_attempts=0) as device:
+                match argv.operation:
+                    case 'write':
+                        return asyncio.run(serial_write(device, argv.serial))
+                    case 'read':
+                        return asyncio.run(serial_read(device))
+                    case _:
+                        console.print('Unknown command', style='red bold')
+                        return -1
+        except OSError:
+            # NOTE: we are trying to close an already closed port (in device_test()), 
+            # thus an OSError occurs (invalid file descriptor)
+            return 0
+        except esptool.util.FatalError as err:
+            logger.debug(err)
+            time.sleep(1.0)
+    print("Can't connect to the device")
+    return -1
+
+
+    

{aj090_hw_tools-0.0.4 → aj090_hw_tools-0.0.5}/src/aj090_hw_tools/tools/test.py

@@ -2,9 +2,7 @@ import asyncio
 import logging
 import pexpect
 import pexpect.spawnbase
-import serial
-import serial.rs485
-import serial.tools.list_ports_linux
+import re
 import time
 import esptool
 
@@ -14,6 +12,8 @@ from pexpect.fdpexpect import fdspawn
 from typing import Optional, Type, NamedTuple
 from esptool.cmds import detect_chip
 
+from ..common.const import SERIAL_NUM_PATTERN
+
 DEFAULT_BAUDRATE = 115200
 DEFAULT_SERIAL_TIMEOUT_IN_SECONDS = 2 
 
@@ -50,10 +50,6 @@ def red(text) -> str:
 def green(text) -> str:
     return Style.BRIGHT + Fore.GREEN + f'{text}' + Style.RESET_ALL
 
-def open_serial_port(port):
-    serInstance = serial.Serial(port, DEFAULT_BAUDRATE, timeout=DEFAULT_SERIAL_TIMEOUT_IN_SECONDS)
-    return serInstance
-
 class TestError(Exception):
     def __init__(self, message, expected_output: str = None, before: str = None):
         super().__init__(message)
@@ -82,9 +78,9 @@ async def do_test(dut: DUT, unit:str, expected: str, timeout: float = 5.0) -> in
 
 async def device_boot_test(dut: DUT) -> BootInfo:
     boot_expect = [
-        'boot: ESP-IDF v(\d\.\d|\d\.\d+-dirty) 2nd stage bootloader',
-        'boot: Loaded app from partition at offset (0x\d{5,})',
-        'app_init: App version:\s+(\w{7})'
+        r'boot: ESP-IDF v(\d\.\d|\d\.\d+-dirty) 2nd stage bootloader',
+        r'boot: Loaded app from partition at offset (0x\d{5,})',
+        r'app_init: App version:\s+(\w{7})'
     ]
 
     await do_test(dut, '2nd stage bootloader', boot_expect[0])
@@ -105,16 +101,16 @@ async def device_boot_test(dut: DUT) -> BootInfo:
 
 async def common_modules_init_test(dut: DUT) -> int:
     expected_outputs = [
-        ('Firmware manager', 'FW_MANAGER: Firmware manager has been successfully initialized'),
-        ('File storage', 'STORAGE: Storage manager has been successfully initialized'),
-        ('Configuration manager', 'CFG_MANAGER: Configuration manager has been successfully initialized'),
-        ('Board', 'BOARD: Board has been successfully initialized')
+        ('Firmware manager', r'FW_MANAGER: Firmware manager has been successfully initialized'),
+        ('File storage', r'STORAGE: Storage manager has been successfully initialized'),
+        ('Configuration manager', r'CFG_MANAGER: Configuration manager has been successfully initialized'),
+        ('Board', r'BOARD: Board has been successfully initialized')
     ]
     for unit, output in expected_outputs:
         await do_test(dut, unit, output)
 
 async def board_type_test(dut: DUT) -> str:
-    await do_test(dut, 'Board type', 'MAIN: Starting (?:\w+ )?(CELL|SHELF) CONTROLLER application')
+    await do_test(dut, 'Board type', r'MAIN: Starting (?:\w+ )?(CELL|SHELF) CONTROLLER application')
     board_type = dut.match.group(1).decode('utf-8').lower()
     return board_type.lower()
 
@@ -125,8 +121,10 @@ async def device_info_test(dut: DUT) -> DeviceInfo:
     #     sha256: 3c050c5d0ea4aea33643eba2b7e840c607af710176e4387b3b22f183c920f09e
     #     hw version: 1.0
     #     MAC: 64:E8:33:48:EF:C4
-    #     serial: AJ090_SC_XX_XXXXXXXX
-    MATCH_PATTERN = 'DEVICE_INFO:\s+app version:\s+(\w{7})\s+compile time:\s+(\d{2}:\d{2}:\d{2})\s+sha256:\s+(\w{64})\s+hw version:\s+(\d{1}\.\d{1})\s+MAC:\s+(\w{2}:\w{2}:\w{2}:\w{2}:\w{2}:\w{2})\s+serial:\s+(AJ090_(?:SC|CC)_\w+)'
+    #     serial: XXXXXXXX
+    MATCH_PATTERN = re.compile(
+        r'DEVICE_INFO:\s+app version:\s+(\w{{7}})\s+compile time:\s+(\d{{2}}:\d{{2}}:\d{{2}})\s+sha256:\s+(\w{{64}})\s+hw version:\s+(\d{{1}}\.\d{{1}})\s+MAC:\s+(\w{{2}}:\w{{2}}:\w{{2}}:\w{{2}}:\w{{2}}:\w{{2}})\s+serial:\s+({SERIAL_NUM_PATTERN})'.format(SERIAL_NUM_PATTERN=SERIAL_NUM_PATTERN)
+    )
     await do_test(dut, 'Device info', MATCH_PATTERN)
     device_info = DeviceInfo(
         app_ver      = dut.match.group(1).decode('utf-8').lower(),
@@ -139,24 +137,24 @@ async def device_info_test(dut: DUT) -> DeviceInfo:
     return device_info
 
 async def cell_test(dut: DUT, app_version: str) -> int:
-    await do_test(dut, 'Cells initialization', 'CELL_CONTROLLER: initialize cells of the (\w{6,9}) board')
+    await do_test(dut, 'Cells initialization', r'CELL_CONTROLLER: initialize cells of the (\w{6,9}) board')
     cell_type = dut.match.group(1).decode('utf-8').lower()
-    await do_test(dut, 'Application', 'MAIN: The application has been successfully initialized')
+    await do_test(dut, 'Application', r'MAIN: The application has been successfully initialized')
     match cell_type:
         case 'retail':
-            await do_test(dut, 'Cells#0 measurements', 'CELL_CONTROLLER: cell#0 measure result', timeout=20)
-            await do_test(dut, 'Cells#1 measurements', 'CELL_CONTROLLER: cell#1 measure result', timeout=20)
+            await do_test(dut, 'Cells#0 measurements', r'CELL_CONTROLLER: cell#0 measure result', timeout=20)
+            await do_test(dut, 'Cells#1 measurements', r'CELL_CONTROLLER: cell#1 measure result', timeout=20)
         case 'wholesale':
-            await do_test(dut, 'Cell measurements', 'CELL_CONTROLLER: cell#0 measure result', timeout=20)
+            await do_test(dut, 'Cell measurements', r'CELL_CONTROLLER: cell#0 measure result', timeout=20)
         case _:
             raise TestError(f'Unknown cell type: {cell_type}')
     return 0
 
 async def shelf_test(dut: DUT, app_version: str) -> int:
-    await do_test(dut, 'Main task start', 'SHELF_CONTROLLER: Shelf controller main task started')
-    await do_test(dut, 'Environment sensor initialization', 'ENV_SENSOR: sensor created')
-    await do_test(dut, 'Application', 'MAIN: The application has been successfully initialized')
-    await do_test(dut, 'Environment sensor measurements', 'SHELF_CONTROLLER: Temperature: (\d{1,3}[.,]\d+); humudity: (\d{1,2}[.,]\d+)')
+    await do_test(dut, 'Main task start', r'SHELF_CONTROLLER: Shelf controller main task started')
+    await do_test(dut, 'Environment sensor initialization', r'ENV_SENSOR: sensor created')
+    await do_test(dut, 'Application', r'MAIN: The application has been successfully initialized')
+    await do_test(dut, 'Environment sensor measurements', r'SHELF_CONTROLLER: Temperature: (\d{1,3}[.,]\d+); humudity: (\d{1,2}[.,]\d+)')
 
     return 0
 

aj090_hw_tools-0.0.4/src/aj090_hw_tools/tools/serial_number.py

@@ -1,7 +0,0 @@
-__all__ = [
-    'serial'
-]
-
-
-def serial(argv) -> int:
-    pass