aj090-hw-tools 0.0.4__tar.gz

aj090_hw_tools-0.0.4/.gitignore

@@ -0,0 +1,174 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc

aj090_hw_tools-0.0.4/LICENSE.txt

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025-present Vasencheg <vasencheg@gmail.com>
+
+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.

aj090_hw_tools-0.0.4/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: aj090-hw-tools
+Version: 0.0.4
+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
+Author-email: Vasencheg <vasencheg@gmail.com>
+License-Expression: MIT
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+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 :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.8
+Requires-Dist: aioconsole>=0.8.1
+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: esptool==4.8.1
+Requires-Dist: numpy>=2.2.4
+Requires-Dist: pexpect>=4.9.0
+Requires-Dist: pyserial>=3.5
+Requires-Dist: rich>=14.0.0
+Description-Content-Type: text/markdown
+
+# aj090_hw_tools
+
+[![PyPI - Version](https://img.shields.io/pypi/v/aj090-hw-tools.svg)](https://pypi.org/project/aj090-hw-tools)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/aj090-hw-tools.svg)](https://pypi.org/project/aj090-hw-tools)
+
+-----
+
+## Table of Contents
+
+- [Installation](#installation)
+- [License](#license)
+
+## Installation
+
+```console
+pip install aj090-hw-tools
+```
+
+## License
+
+`aj090-hw-tools` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

aj090_hw_tools-0.0.4/README.md

@@ -0,0 +1,21 @@
+# aj090_hw_tools
+
+[![PyPI - Version](https://img.shields.io/pypi/v/aj090-hw-tools.svg)](https://pypi.org/project/aj090-hw-tools)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/aj090-hw-tools.svg)](https://pypi.org/project/aj090-hw-tools)
+
+-----
+
+## Table of Contents
+
+- [Installation](#installation)
+- [License](#license)
+
+## Installation
+
+```console
+pip install aj090-hw-tools
+```
+
+## License
+
+`aj090-hw-tools` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

aj090_hw_tools-0.0.4/pyproject.toml

@@ -0,0 +1,79 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "aj090-hw-tools"
+dynamic = ["version"]
+description = ''
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+keywords = []
+authors = [
+  { name = "Vasencheg", email = "vasencheg@gmail.com" },
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+]
+dependencies = [
+  "pyserial>=3.5",
+  "esptool==4.8.1",
+  "esp_idf_nvs_partition_gen==0.1.8",
+  "pexpect>=4.9.0",
+  "configargparse>=1.7",
+  "aiohttp>=3.11.14",
+  "aiofile>=3.9.0",
+  "aioconsole>=0.8.1",
+  "numpy>=2.2.4",
+  "colorama>=0.4.6",
+  "rich>=14.0.0"
+]
+
+[project.urls]
+Documentation = "https://github.com/Vasencheg/aj090-hw-tools#readme"
+Issues = "https://github.com/Vasencheg/aj090-hw-tools/issues"
+Source = "https://github.com/Vasencheg/aj090-hw-tools"
+
+[tool.hatch.version]
+path = "src/aj090_hw_tools/__about__.py"
+
+[tool.hatch.envs.types]
+extra-dependencies = [
+  "mypy>=1.0.0",
+]
+[tool.hatch.envs.types.scripts]
+check = "mypy --install-types --non-interactive {args:src/aj090_hw_tools tests}"
+
+[tool.coverage.run]
+source_pkgs = ["aj090_hw_tools", "tests"]
+branch = true
+parallel = true
+omit = [
+  "src/aj090_hw_tools/__about__.py",
+]
+
+[tool.coverage.paths]
+aj090_hw_tools = ["src/aj090_hw_tools", "*/aj090-hw-tools/src/aj090_hw_tools"]
+tests = ["tests", "*/aj090-hw-tools/tests"]
+
+[tool.coverage.report]
+exclude_lines = [
+  "no cov",
+  "if __name__ == .__main__.:",
+  "if TYPE_CHECKING:",
+]
+
+[tool.hatch.envs.default]
+system-packages = true
+
+[project.scripts]
+aj090-hw-tools = 'aj090_hw_tools.__main__:script_ep'

aj090_hw_tools-0.0.4/src/aj090_hw_tools/__about__.py

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

aj090_hw_tools-0.0.4/src/aj090_hw_tools/__init__.py

@@ -0,0 +1,71 @@
+import sys
+import configargparse
+
+from .__about__ import __version__
+from .tools import (
+    firmware,
+    test,
+    info
+)
+
+__all__ = [
+    "_main"
+]
+
+def _main():
+    parser = configargparse.ArgParser(
+        description="aj090-hw-tools.py v%s - AJ090 hardware tools"
+        % __version__,
+        prog="aj090-hw-tools",
+    )
+
+    parser.add_argument(
+        "--port",
+        "-p",
+        help="Serial port device",
+        env_var="AJ090_HW_PORT",
+    )
+
+    parser.add_argument('-c', '--config', is_config_file=True, help='config file path')
+
+    parser.add_argument('device', type=str, choices=['cell', 'shelf'], help='device')
+
+    subparsers = parser.add_subparsers(title='Device tools', dest='tools', help='Run aj090-hw-tools {device} {tool} -h for additional help')
+
+    # Firmware operations
+    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')
+
+    # Info
+    parser_firmware = subparsers.add_parser('info', help='device info')
+    parser_firmware.set_defaults(func=info)
+
+    # Test
+    parser_test = subparsers.add_parser('test', help='device tests')
+    parser_test.set_defaults(func=test)
+
+    # Serial
+    parser_serial = subparsers.add_parser('serial', help='device serial number operations')
+
+    # Factory
+    # parser_factory = subparsers.add_parser('factory_mode', help='device factory mode control')
+
+    if len(sys.argv) <= 1:
+        parser.print_help()
+        sys.exit(-1)
+
+    args = parser.parse_args()
+
+    try:
+        return args.func(args)
+    except KeyboardInterrupt:
+        sys.exit(-1)
+    
+if __name__ == '__main__':
+    try:
+        sys.exit(_main())
+    except Exception as ex:
+        print(ex)
+        sys.exit(-1)

aj090_hw_tools-0.0.4/src/aj090_hw_tools/__main__.py

@@ -0,0 +1,7 @@
+import aj090_hw_tools
+
+def script_ep():
+    aj090_hw_tools._main()
+
+if __name__ == '__main__':
+    script_ep()

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

@@ -0,0 +1,4 @@
+from .firmware import firmware
+from .test import test
+from .serial_number import serial
+from .info import info

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

@@ -0,0 +1,294 @@
+import os
+import asyncio
+import aiohttp
+import logging
+import re
+import esptool
+import numpy as np
+import tempfile
+
+from aiofile import async_open
+from aioconsole import aprint, ainput
+from contextlib import AbstractAsyncContextManager
+from types import TracebackType
+from typing import Any, Optional, Dict, Type, NamedTuple
+from esptool.cmds import detect_chip
+from pathlib import Path
+
+
+__all__ = [
+    'firmware'
+]
+
+
+FIRMWARE_PATTERN = {
+    "cell" : r'aj090_cell_controller_firmware_(\w{7}).bin',
+    "shelf": r'aj090_shelf_controller_firmware_(\w{7}).bin'
+}
+
+# Logger 
+FORMAT = '%(name)s:%(levelname)s: %(message)s'
+logging.basicConfig(level=logging.ERROR, format=FORMAT)
+logger = logging.getLogger(__name__)
+
+
+class GitHubReleaseManager(AbstractAsyncContextManager):
+    """
+    """
+    API_VERSION = '2022-11-28'
+
+    class GitHubError(Exception):
+        pass
+
+    def __init__(
+        self, 
+        repo_owner: str, 
+        repo: str, 
+        *, 
+        token: str
+    ):
+        self._repo_owner: str = repo_owner
+        self._repo: str = repo
+        self._token: str = token
+        self._session: Optional[aiohttp.ClientSession] = None
+          
+    async def latest_release_info_get(self) -> Dict[str, Any]:
+        """
+        curl -L -H "Accept: application/vnd.github+json" \
+            -H "Authorization:Bearer github_pat_11BGD5X..." \
+            -H "X-GitHub-Api-Version: 2022-11-28" \
+                https://api.github.com/repos/owner/repo/releases/latest
+        """
+        async with self._session.get(
+                url     = f'https://api.github.com/repos/{self._repo_owner}/{self._repo}/releases/latest',
+                headers = {
+                    'Accept': 'application/vnd.github+json',
+                }
+            ) as resp:
+            if resp.status == 200:
+                return await resp.json()
+            else:
+                raise self.GitHubError('Release not found')
+
+    async def asset_download(self, asset_download_url: str, output_file: str) -> int:
+        """
+        returns downloaded asset size in bytes
+        """
+        async with self._session.get(
+            url     = asset_download_url,
+            headers = {
+                'Accept': 'application/octet-stream'
+            }
+        ) as response:
+            if response.status == 200:
+                async with async_open(output_file, 'wb') as output_file:
+                    chunk_size = 4096
+                    asset_size = 0
+                    async for data in response.content.iter_chunked(chunk_size):
+                        asset_size += await output_file.write(data)
+                    return asset_size
+            else:
+               raise self.GitHubError('Asset download failed') 
+    
+    async def __aenter__(self) -> None:
+        loop = asyncio.get_running_loop()
+        self._session: aiohttp.ClientSession = aiohttp.ClientSession(
+            loop    = loop,
+            headers = {
+                'Authorization'       : f'Bearer {self._token}',
+                'X-GitHub-Api-Version': self.API_VERSION
+            }
+        )
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc: Optional[BaseException],
+        tb: Optional[TracebackType],
+    ) -> None:
+        await self._session.close()
+        return None
+
+class FirmwareInfo(NamedTuple):
+    version: str
+    project: str
+    build_time: str
+    build_date: str
+    idf: str
+    sha: str
+
+class Firmware():
+    """
+    """
+    def __init__(self, port: Optional[str] = None):
+        self._port: str = port if port is not None else esptool.ESPLoader.DEFAULT_PORT
+
+    @staticmethod
+    async def info(firmware_file: str) -> FirmwareInfo:
+        """
+            typedef struct {
+                uint32_t magic_word;        /*!< Magic word ESP_APP_DESC_MAGIC_WORD */
+                uint32_t secure_version;    /*!< Secure version */
+                uint32_t reserv1[2];        /*!< reserv1 */
+                char version[32];           /*!< Application version */
+                char project_name[32];      /*!< Project name */
+                char time[16];              /*!< Compile time */
+                char date[16];              /*!< Compile date*/
+                char idf_ver[32];           /*!< Version IDF */
+                uint8_t app_elf_sha256[32]; /*!< sha256 of elf file */
+                uint16_t min_efuse_blk_rev_full; /*!< Minimal eFuse block revision supported by image, in format: major * 100 + minor */
+                uint16_t max_efuse_blk_rev_full; /*!< Maximal eFuse block revision supported by image, in format: major * 100 + minor */
+                uint8_t mmu_page_size;      /*!< MMU page size in log base 2 format */
+                uint8_t reserv3[3];         /*!< reserv3 */
+                uint32_t reserv2[18];       /*!< reserv2 */
+            } esp_app_desc_t;
+        """
+        INFO_OFFSET = 262144 + 32
+
+        esp_app_desc_t = np.dtype([
+            ('magic_word', '<u4'),
+            ('secure_version', '<u4'),
+            ('reserv1', '<u4', (2,)),
+            ('version', '<u1', (32,)),
+            ('project_name', '<u1', (32,)),
+            ('time', '<u1', (16,)),
+            ('date', '<u1', (16,)),
+            ('idf_ver', '<u1', (32,)),
+            ('app_elf_sha256', '<u1', (32,)),
+            ('min_efuse_blk_rev_full', '<u2'),
+            ('max_efuse_blk_rev_full', '<u2'),
+            ('reserv3', '<u1', (3,)),
+            ('reserv2', '<u4', (18,)),
+        ])
+
+        async with async_open(firmware_file, 'rb') as file:
+            file.seek(INFO_OFFSET)
+            b = await file.read(esp_app_desc_t.itemsize)
+
+        app_desc = np.frombuffer(b, esp_app_desc_t)
+        sha      = ''.join([f'{d:02x}' for d in app_desc['app_elf_sha256'].tobytes()])
+        def to_str(nd_array):
+            return nd_array.tobytes().decode().rstrip('\x00')
+
+        return FirmwareInfo(
+            version    = to_str(app_desc['version']),
+            project    = to_str(app_desc['project_name']),
+            build_time = to_str(app_desc['time']),
+            build_date = to_str(app_desc['date']),
+            idf        = to_str(app_desc['idf_ver']),
+            sha        = sha
+        )
+
+    async def write(self, firmware: str) -> None:
+        def _write():
+            with detect_chip(port=self._port, connect_attempts=0) as esp:
+                command = ['write_flash', '0', f'{firmware}']
+                logger.debug("Using command ", " ".join(command))
+                esptool.main(command, esp)
+
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, _write)    
+        
+    async def erase(self) -> None:
+        def _erase():
+            with detect_chip(port=self._port, connect_attempts=0) as esp:
+                command = ['erase_flash']
+                logger.debug("Using command ", " ".join(command))
+                esptool.main(command, esp)
+
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, _erase)  
+
+
+async def firmware_flasher(argv):
+    """
+    """
+    # Create FirmwareFlasher
+    firmware = Firmware(argv.port)
+
+    match argv.operation:
+        case 'write':
+            # Download the firmware from GitHub if the bin_file was not passed directly to the arguments.
+            if argv.bin_file is None:
+                gh_token = os.getenv('AJ090_FWU_TOKEN', None)
+                fw_owner = os.getenv('AJ090_FWU_OWNER', 'Vasencheg-AJPT')
+                fw_repo  = os.getenv('AJ090_FWU_REPO', 'aj090_firmware')
+
+                if gh_token is None:
+                    await aprint('There is no token for accessing the firmware repository!!!')
+                    return -1
+
+                try:
+                    async with GitHubReleaseManager(fw_owner, fw_repo, token=gh_token) as github:
+                        info       = await github.latest_release_info_get()
+                        assets     = info['assets']
+                        commit_sha = info['target_commitish']
+                        result     = list(filter(lambda i: re.match(FIRMWARE_PATTERN[argv.device], i['name']), assets))
+                        # validate result
+                        if len(result):
+                            firmware_info = {
+                                'version': commit_sha[:7],
+                                'url'    : result[0]['url'],
+                                'name'   : result[0]['name']
+                            }
+                            
+                            fwu_file = str(Path(tempfile.gettempdir()).joinpath(firmware_info['name']))
+
+                            if not os.path.exists(fwu_file):
+                                await aprint('The latest firmware version is being downloaded...')
+                                await github.asset_download(firmware_info['url'], fwu_file)
+                            else:
+                                await aprint('A cached firmware file is being used...')
+                            
+                            bin_file = fwu_file
+                        else:
+                            await aprint('No firmware found')
+                            return -1
+                except GitHubReleaseManager.GitHubError as err:
+                    await aprint(f'An error occured: {err}')
+                    # TODO: search for cached firmwares and flash it
+                    return -1
+            else:
+                await aprint('A local firmware file is being used...')
+                bin_file = argv.bin_file
+
+            # Get firmware info
+            fw_info = await Firmware.info(bin_file)
+
+            await aprint(
+"""Firmware information:
+    version     : {version}
+    build time  : {build_time}
+    build date  : {build_date}
+    SHA         : {sha}
+""".format(version=fw_info.version, build_time=fw_info.build_time, build_date=fw_info.build_date, sha=fw_info.sha)
+            )
+
+            operation = firmware.write(bin_file)
+       
+        case 'erase':
+            operation = firmware.erase()
+
+        case _:
+            raise Exception('Unsupported flash operation')
+
+    try:
+        await ainput('Press Any key to continue or Ctrl^C to abort operation: ')
+        await operation
+    except asyncio.CancelledError:
+        await aprint('\r\n')
+        await aprint('Operation aborted')
+        operation.close()
+        return -1
+    except Exception as ex:
+        await aprint(f'An unexpected exception occured: {ex}')
+        return -1
+    else:
+        await aprint('DONE!')
+        
+    return 0
+
+
+def firmware(argv) -> int:
+    return asyncio.run(firmware_flasher(argv))

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

@@ -0,0 +1,128 @@
+import asyncio
+import logging
+import pexpect
+import pexpect.spawnbase
+import time
+import esptool
+
+from rich.console import Console
+from rich.table import Table
+from pexpect.fdpexpect import fdspawn
+from typing import Optional, Type, NamedTuple
+from esptool.cmds import detect_chip
+
+__all__ = [
+    'info'
+]
+
+# Logger 
+FORMAT = '%(name)s:%(levelname)s: %(message)s'
+logging.basicConfig(level=logging.ERROR, format=FORMAT)
+logger = logging.getLogger(__name__)
+
+# Rich console
+console = Console()
+
+DUT = Type[pexpect.spawnbase.SpawnBase]
+
+class GatherInfoError(Exception):
+    def __init__(self, message):
+        super().__init__(message)
+        self._message : str           = message
+
+class DeviceInfo(NamedTuple):
+    """ Base device information """
+    app_ver: str
+    compile_time: str
+    app_sha: str
+    hw_ver: str
+    mac:str
+    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)
+    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()
+    return board_type.lower()
+
+async def device_info_get(dut: DUT) -> Optional[DeviceInfo]:
+    # I (00:00:01.100) DEVICE_INFO: 
+    #     app version: b366ae1
+    #     compile time: 13:00:08
+    #     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+)'
+    result = await dut.expect([MATCH_PATTERN, pexpect.TIMEOUT], timeout=5.0, async_=True)
+    if result:
+        raise GatherInfoError('Failed to collect information about the device')
+    device_info = DeviceInfo(
+        app_ver      = dut.match.group(1).decode('utf-8').lower(),
+        compile_time = dut.match.group(2).decode('utf-8').lower(),
+        app_sha      = dut.match.group(3).decode('utf-8').lower(),
+        hw_ver       = dut.match.group(4).decode('utf-8').lower(),
+        mac          = dut.match.group(5).decode('utf-8').lower(),
+        sn           = dut.match.group(6).decode('utf-8').lower()
+    )
+    return device_info
+
+async def gather_info(device, argv) -> int:
+    device.hard_reset()
+
+    # NOTE: we are working with an already open port in another place (ESPLoader) !!!
+    dut: DUT = fdspawn(device._port, timeout=180)
+    last_error = 0
+    try:
+        # get board type
+        board_type = await board_type_get(dut)
+
+        # get device info
+        dev_info = await device_info_get(dut)
+
+        table = Table(title=f"{board_type.capitalize()} controller information", show_lines=True)
+
+        table.add_column("Info", justify="left", style="cyan", no_wrap=True)
+        table.add_column("Value", justify="left", style="green")
+
+        table.add_row('Application version', dev_info.app_ver)
+        table.add_row('Application SHA', dev_info.app_sha)
+        table.add_row('Hardware version', dev_info.hw_ver)
+        table.add_row('MAC', dev_info.mac)
+        table.add_row('Serial number', dev_info.sn)
+
+        console.print(table)
+
+    except GatherInfoError as err:
+        console.print(err, style="bold red")
+        last_error = -1
+    except pexpect.TIMEOUT:
+        console.print('Waiting time exceeded', style="bold red")
+        last_error = -1
+        
+    try:
+        dut.close()
+    except OSError as err:
+        logger.debug(f'OSError: {err}')
+
+    return last_error
+
+
+def info(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:
+                return asyncio.run(gather_info(device, argv))
+        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)
+
+    console.print("Can't connect to the device", style="bold red")
+    return -1

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

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

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

@@ -0,0 +1,224 @@
+import asyncio
+import logging
+import pexpect
+import pexpect.spawnbase
+import serial
+import serial.rs485
+import serial.tools.list_ports_linux
+import time
+import esptool
+
+from aioconsole import aprint
+from colorama import Fore, Style
+from pexpect.fdpexpect import fdspawn
+from typing import Optional, Type, NamedTuple
+from esptool.cmds import detect_chip
+
+DEFAULT_BAUDRATE = 115200
+DEFAULT_SERIAL_TIMEOUT_IN_SECONDS = 2 
+
+# Logger 
+FORMAT = '%(name)s:%(levelname)s: %(message)s'
+logging.basicConfig(level=logging.ERROR, format=FORMAT)
+logger = logging.getLogger(__name__)
+
+DUT = Type[pexpect.spawnbase.SpawnBase]
+
+class BootInfo(NamedTuple):
+    idf_version: str
+    boot_offset: str
+    app_version: str
+
+class DeviceInfo(NamedTuple):
+    """ Base device information """
+    app_ver: str
+    compile_time: str
+    app_sha: str
+    hw_ver: str
+    mac:str
+    sn: str
+
+def br(text) -> str:
+    return Style.BRIGHT + f'{text}' + Style.RESET_ALL
+
+def yellow(text) -> str:
+    return Fore.YELLOW + f'{text}' + Style.RESET_ALL
+
+def red(text) -> str:
+    return Style.BRIGHT + Fore.RED + f'{text}' + Style.RESET_ALL
+
+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)
+        self._message : str           = message
+        self._expected: Optional[str] = expected_output
+        self._before  : Optional[str] = before
+    
+    @property
+    def before(self) -> Optional[str]:
+        return self._before
+
+    def __str__(self):
+        if self._expected is not None:
+            return f'{red(self._message)}:\r\n\t{br("Expected output")}: {self._expected}'
+        else:
+            return f'{red(self._message)}'
+
+async def do_test(dut: DUT, unit:str, expected: str, timeout: float = 5.0) -> int:
+    result = await dut.expect([expected, pexpect.TIMEOUT], timeout=timeout, async_=True)
+    if result:
+        raise TestError(f'{unit} test error', expected, dut.before)
+    else:
+        await aprint(f'{unit} test: {green("OK")}')
+
+    return result
+
+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})'
+    ]
+
+    await do_test(dut, '2nd stage bootloader', boot_expect[0])
+    idf_version = dut.match.group(1).decode('utf-8').lower()
+    await do_test(dut, 'Load app', boot_expect[1])
+    boot_offset = dut.match.group(1).decode('utf-8')
+    await do_test(dut, 'App version', boot_expect[2])
+    app_version = dut.match.group(1).decode('utf-8').lower()
+
+    boot_info = BootInfo(
+        idf_version = idf_version,
+        app_version = app_version,
+        boot_offset = boot_offset
+    )
+    logger.debug(f'Device boot info: {boot_info}')
+
+    return boot_info
+
+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')
+    ]
+    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')
+    board_type = dut.match.group(1).decode('utf-8').lower()
+    return board_type.lower()
+
+async def device_info_test(dut: DUT) -> DeviceInfo:
+    # I (00:00:01.100) DEVICE_INFO: 
+    #     app version: b366ae1
+    #     compile time: 13:00:08
+    #     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+)'
+    await do_test(dut, 'Device info', MATCH_PATTERN)
+    device_info = DeviceInfo(
+        app_ver      = dut.match.group(1).decode('utf-8').lower(),
+        compile_time = dut.match.group(2).decode('utf-8').lower(),
+        app_sha      = dut.match.group(3).decode('utf-8').lower(),
+        hw_ver       = dut.match.group(4).decode('utf-8').lower(),
+        mac          = dut.match.group(5).decode('utf-8').lower(),
+        sn           = dut.match.group(6).decode('utf-8').lower()
+    )
+    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')
+    cell_type = dut.match.group(1).decode('utf-8').lower()
+    await do_test(dut, 'Application', '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)
+        case 'wholesale':
+            await do_test(dut, 'Cell measurements', '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+)')
+
+    return 0
+
+async def device_test(device, argv):
+    device.hard_reset()
+
+    # NOTE: we are working with an already open port in another place (ESPLoader) !!!
+    dut: DUT = fdspawn(device._port, timeout=180)
+    last_error = 0
+    try:
+        boot_info = await device_boot_test(dut)
+        await aprint(yellow(f'Device boot info: {boot_info}'))
+        await common_modules_init_test(dut)
+
+        board_type = await board_type_test(dut)
+        if argv.device != board_type:
+            raise TestError(f'Wrong board type. Got: {board_type.upper()}', f'{argv.device.upper()}')
+        
+        device_info = await device_info_test(dut)
+        await aprint(yellow(f'Device info: {device_info}'))
+
+        match argv.device:
+            case 'cell':
+                last_error = await cell_test(dut, device_info.app_ver)
+            case 'shelf':
+                last_error = await shelf_test(dut, device_info.app_ver)
+
+            case _:
+                raise Exception('Unsupported device')
+    except TestError as err:
+        await aprint(err)
+        last_error = -1
+    except pexpect.TIMEOUT:
+        await aprint('Waiting time exceeded')
+        last_error = -1
+        
+    try:
+        dut.close()
+    except OSError as err:
+        logger.debug(f'OSError: {err}')
+
+    if last_error:
+        await aprint(red('FAILED'))
+    else:
+        await aprint(green('PASSED'))
+        
+    return last_error
+
+
+def test(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:
+                return asyncio.run(device_test(device, argv))
+        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/tests/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2025-present Vasencheg <roman.vasilev@nobitlost.com>
+#
+# SPDX-License-Identifier: MIT