adt7410_async_driver

MicroPython driver for the Analog Devices ADT7410 high-accuracy digital temperature sensor

1.0.0 yangcong-bit 更新时间: 2026-11-10
安装包
本地安装
mpremote mip install https://upypi.net/pkgs/adt7410_async_driver/1.0.0
远程安装
mip.install("https://upypi.net/pkgs/adt7410_async_driver/1.0.0")
版本选择
README

MicroPython driver for the Analog Devices ADT7410 high-accuracy digital temperature sensor — MicroPython 异步驱动

实验性异步版本:尚未完成实物验收。

同步来源:同步版本。维护者说明同步版本已验证;本次未逐包复测同步来源,适用硬件和固件范围以原有记录为准。

异步版本:本包 Python 源码及示例已通过 MicroPython 1.23 / 1.29 编译检查;软件回归只覆盖选定路径,不代表本包全部 API、实际器件及并发行为已验证。

仓库验证说明 · 两轮软件检查 · 受限清单 · 安装与初始化迁移

目录

简介

adt7410_async_driver 是当前仓库中独立发布的 MicroPython 异步包。设备/功能名称和 API 均来自包内运行时文件;它不是对同步 API 的无依据重命名。源包:sensors/adt7410_driver。

主要功能

  • 可解析的公开类:ADT7410, ADT7410Async, CBits, RegisterStruct, SyncAdapterMixin。
  • 可解析的公开调用入口:58 个(详见 API 矩阵)。
  • 异步等级:not_async_safe;异步包装不能消除同步 I2C 阻塞;在取得可复现阻塞上界前不得作为可用异步驱动交付。

硬件要求

项目 从代码取得的事实
通信/IO I2C, Pin(
示例 GPIO 示例未声明固定 GPIO 编号
供电、地址与电平 仅按模块实物标签、数据手册及代码常量配置;。

软件环境

项目 值
运行时 MicroPython + uasyncio
包版本 1.0.0
作者 Jose D. Montoya
依赖 无声明的第三方依赖

文件结构

├── code/__init__.py
├── code/__pycache__/__init__.cpython-313.pyc
├── code/__pycache__/adt7410.cpython-313.pyc
├── code/__pycache__/i2c_helpers.cpython-313.pyc
├── code/__pycache__/main.cpython-313.pyc
├── code/_gs_adt7410_adt7410.py
├── code/adt7410_async.py
├── code/_gs_adt7410_i2c_helpers.py
├── code/main.py
├── examples/main_sync.py
├── LICENSE
└── package.json

文件说明

  • code/:实际发布的运行时 Python 模块;以 package.json.urls 为安装映射依据。
  • code/main.py(若存在):异步演示入口,不是默认发布运行时映射。
  • examples/(若存在):同步保真基线或额外示例,不应当作安装后的运行时模块。
  • package.json、LICENSE:发布元数据和许可证的唯一事实来源。

快速开始

  1. 按 package.json.urls 将运行时文件复制到设备;不要把 examples/ 当作运行时依赖。
  2. 按上文硬件/运行环境配置总线、GPIO、网络或凭证。
  3. 使用包内真实 code/main.py 的 import 与构造方式运行。以下是当前文件逐字读取的异步入口;部署时请保留 try/finally 并调用对象实际提供的 deinit() 或 aclose()。
try:
    import uasyncio as asyncio
except ImportError:
    import asyncio

async def main():
    # Python env   : MicroPython v1.23.0
    # -*- coding: utf-8 -*-
    # @Time    : 2026/07/25
    # @Author  : Jose D. Montoya
    # @File    : main.py
    # @Description : 测试 ADT7410 高精度数字温度传感器驱动类
    # @License : MIT

    # ======================================== 导入相关模块 =========================================
    from machine import Pin, I2C
    from _gs_adt7410_adt7410 import (
        ADT7410,
        CONTINUOUS,
        ONE_SHOT,
        SPS,
        SHUTDOWN,
        LOW_RESOLUTION,
        HIGH_RESOLUTION,
        COMP_DISABLED,
        COMP_ENABLED,
    )


    # ======================================== 全局变量 ============================================

    # I2C 引脚配置(请根据实际接线修改)
    I2C_SCL_PIN = 5
    I2C_SDA_PIN = 4

    # ADT7410 参数
    I2C_ADDR = 0x48
    WHOAMI_REG = 0x0B
    EXPECTED_DEVICE_ID = 0xCB

    # 打印间隔(毫秒)
    PRINT_INTERVAL = 2000

    _sleep = time.sleep

    # ======================================== 功能函数 ============================================


    def print_temperature_detail(adt: object) -> None:
        """
        打印详细的温度信息(低频,自动执行)
        """
        temp = adt.temperature
        mode = adt.operation_mode
        resolution = adt.resolution_mode
        print("Temperature: %.4f C | Mode: %s | Resolution: %s" % (temp, mode, resolution))


    def test_operation_modes(adt: object) -> None:
        """
        遍历所有工作模式并打印当前温度(模式切换,默认注释调用,可 REPL 手动触发)

        测试 CONTINUOUS → ONE_SHOT → SPS → SHUTDOWN 完整切换流程。
        SPS 模式下每秒一次转换,SHUTDOWN 模式下读取最后一次转换结果。
        """
        print("=== Testing All Operation Modes ===")
        for mode_val, mode_name in [
            (CONTINUOUS, "CONTINUOUS"),
            (ONE_SHOT, "ONE_SHOT"),
            (SPS, "SPS"),
            (SHUTDOWN, "SHUTDOWN"),
        ]:
            adt.operation_mode = mode_val
            print("Mode: %s" % mode_name)
            # SPS 模式需等待 1s 获取第一次转换结果
            if mode_val == SPS:
                _sleep(1.5)
            else:
                _sleep(0.3)
            print("  Temperature: %.4f C" % adt.temperature)
        # 恢复到连续模式
        adt.operation_mode = CONTINUOUS
        _sleep(0.3)
        print("=== Operation Mode Test Complete ===\n")


    def test_resolution_modes(adt: object) -> None:
        """
        测试分辨率切换对温度读数的影响(模式切换,默认注释调用,可 REPL 手动触发)

        对比 LOW_RESOLUTION(13 位,0.0625°C)和 HIGH_RESOLUTION(16 位,0.0078°C)。
        """
        print("=== Testing Resolution Modes ===")
        adt.resolution_mode = LOW_RESOLUTION
        _sleep(0.3)
        temp_low = adt.temperature
        print("LOW_RESOLUTION  (13-bit): %.4f C" % temp_low)

        adt.resolution_mode = HIGH_RESOLUTION
        _sleep(0.3)
        temp_high = adt.temperature
        print("HIGH_RESOLUTION (16-bit): %.4f C" % temp_high)
        print("Difference: %.4f C" % abs(temp_high - temp_low))
        print("=== Resolution Mode Test Complete ===\n")


    def test_comparator_mode(adt: object) -> None:
        """
        测试比较器模式开关(模式切换,默认注释调用,可 REPL 手动触发)

        演示设置温度阈值后启用比较器模式,观察告警状态变化。
        """
        print("=== Testing Comparator Mode ===")
        current_temp = adt.temperature
        # 设置阈值:以当前温度为基准 ±5°C
        high_threshold, low_threshold, critical_threshold = (int(current_temp) + 5, int(current_temp) - 5, int(current_temp) + 20)
        adt.high_temperature = high_threshold
        adt.low_temperature = low_threshold
        adt.critical_temperature = critical_threshold
        adt.hysteresis_temperature = 2
        print(
            "Thresholds set: High=%d C, Low=%d C, Critical=%d C, Hysteresis=%d C"
            % (
                adt.high_temperature,
                adt.low_temperature,
                adt.critical_temperature,
                adt.hysteresis_temperature,
            )
        )

        # 启用比较器模式
        adt.comparator_mode = COMP_ENABLED
        print("Comparator mode: %s" % adt.comparator_mode)
        alert = adt.alert_status
        print("Alert status: high=%s low=%s critical=%s" % (alert.high_alert, alert.low_alert, alert.critical_alert))

        # 恢复:禁用比较器
        adt.comparator_mode = COMP_DISABLED
        print("Comparator mode: %s" % adt.comparator_mode)
        print("=== Comparator Mode Test Complete ===\n")


    def test_boundary_thresholds(adt: object) -> None:
        """
        测试温度阈值的边界值设置(边界参数,默认注释调用,可 REPL 手动触发)

        验证 -55°C(最小值)和 150°C(最大值)的阈值设置与读取。
        """
        print("=== Testing Boundary Temperature Thresholds ===")
        original_high = adt.high_temperature
        original_low = adt.low_temperature
        original_critical = adt.critical_temperature
        original_hysteresis = adt.hysteresis_temperature

        # 测试极端值
        adt.high_temperature = 150
        print("High temperature set to max: %d C" % adt.high_temperature)

        adt.low_temperature = -55
        print("Low temperature set to min: %d C" % adt.low_temperature)

        adt.critical_temperature = 150
        print("Critical temperature set to max: %d C" % adt.critical_temperature)

        adt.hysteresis_temperature = 0
        print("Hysteresis set to min: %d C" % adt.hysteresis_temperature)

        adt.hysteresis_temperature = 15
        print("Hysteresis set to max: %d C" % adt.hysteresis_temperature)

        # 恢复原始值
        adt.high_temperature = original_high
        adt.low_temperature = original_low
        adt.critical_temperature = original_critical
        adt.hysteresis_temperature = original_hysteresis
        print("Thresholds restored to original values")
        print("=== Boundary Threshold Test Complete ===\n")


    def test_invalid_operation_mode(adt: object) -> None:
        """
        测试无效操作模式的异常处理(异常参数,默认注释调用,可 REPL 手动触发)
        """
        print("=== Testing Invalid Operation Mode ===")
        try:
            adt.operation_mode = 99
            print("ERROR: Should have raised ValueError!")
        except ValueError as e:
            print("Caught expected ValueError: %s" % e)
        print("=== Invalid Operation Mode Test Complete ===\n")


    def test_invalid_temperature_threshold(adt: object) -> None:
        """
        测试超出范围的温度阈值的异常处理(异常参数,默认注释调用,可 REPL 手动触发)
        """
        print("=== Testing Invalid Temperature Threshold ===")
        try:
            adt.high_temperature = 200
            print("ERROR: Should have raised ValueError!")
        except ValueError as e:
            print("Caught expected ValueError: %s" % e)
        try:
            adt.low_temperature = -100
            print("ERROR: Should have raised ValueError!")
        except ValueError as e:
            print("Caught expected ValueError: %s" % e)
        print("=== Invalid Temperature Threshold Test Complete ===\n")


    def test_invalid_hysteresis(adt: object) -> None:
        """
        测试超出范围的迟滞值的异常处理(异常参数,默认注释调用,可 REPL 手动触发)
        """
        print("=== Testing Invalid Hysteresis ===")
        try:
            adt.hysteresis_temperature = 20
            print("ERROR: Should have raised ValueError!")
        except ValueError as e:
            print("Caught expected ValueError: %s" % e)
        try:
            adt.hysteresis_temperature = -5
            print("ERROR: Should have raised ValueError!")
        except ValueError as e:
            print("Caught expected ValueError: %s" % e)
        print("=== Invalid Hysteresis Test Complete ===\n")


    def test_reset(adt: object) -> None:
        """
        测试传感器复位功能(模式切换,默认注释调用,可 REPL 手动触发)

        复位后验证传感器仍可正常读取温度。
        """
        print("=== Testing Sensor Reset ===")
        print("Before reset - Temperature: %.4f C" % adt.temperature)
        print("Before reset - Operation mode: %s" % adt.operation_mode)
        reset = adt.reset
        reset()
        _sleep(0.3)
        print("After reset  - Temperature: %.4f C" % adt.temperature)
        print("After reset  - Operation mode: %s" % adt.operation_mode)
        print("=== Sensor Reset Test Complete ===\n")


    def test_context_manager(i2c: object) -> None:
        """
        测试上下文管理器(with 语句)自动资源释放(批量操作,默认注释调用,可 REPL 一键执行)
        """
        print("=== Testing Context Manager ===")
        with ADT7410(i2c, address=I2C_ADDR) as adt:
            temp = adt.temperature
            print("Temperature via context manager: %.4f C" % temp)
        print("Context manager exited, resources released")
        print("=== Context Manager Test Complete ===\n")


    def i2c_scan_and_verify(i2c: object, expected_addr: int) -> bool:
        """
        扫描 I2C 总线并验证目标设备是否存在

        Args:
            i2c: I2C 总线实例
            expected_addr: 期望的设备地址

        Returns:
            bool: 设备是否找到并验证通过

        Raises:
            RuntimeError: 总线上无设备或目标设备未找到
        """
        print("Scanning I2C bus...")
        scan = i2c.scan
        devices = (scan)()
        if not devices:
            raise RuntimeError("No I2C device found on bus")
        print("Found %d device(s): %s" % (len(devices), str([hex(d) for d in devices])))

        # 查找目标设备
        if expected_addr not in devices:
            raise RuntimeError("Device not found at expected address 0x%02X, found: %s" % (expected_addr, str([hex(d) for d in devices])))
        print("Target device found at 0x%02X" % expected_addr)

        # 读取芯片 ID 寄存器进行验证
        try:
            readfrom_mem = i2c.readfrom_mem
            whoami = (readfrom_mem)(expected_addr, WHOAMI_REG, 1)[0]
        except OSError as e:
            raise RuntimeError("Failed to read WHOAMI register at 0x%02X" % WHOAMI_REG) from e

        if whoami == EXPECTED_DEVICE_ID:
            print("Device ID verified: 0x%02X (expected 0x%02X) - ADT7410 confirmed" % (whoami, EXPECTED_DEVICE_ID))
            return True
        else:
            print("Device ID mismatch: got 0x%02X, expected 0x%02X" % (whoami, EXPECTED_DEVICE_ID))
            return False


    # ======================================== 自定义类 ============================================

    # ======================================== 初始化配置 ==========================================

    # 上电稳定等待
    await asyncio.sleep(3)

    print("FreakStudio: ADT7410 High-Accuracy Digital Temperature Sensor Test")
    print("=" * 60)

    # 初始化 I2C 总线
    print("Initializing I2C bus: SCL=Pin(%d), SDA=Pin(%d)" % (I2C_SCL_PIN, I2C_SDA_PIN))
    i2c = I2C(0, scl=Pin(I2C_SCL_PIN), sda=Pin(I2C_SDA_PIN))
    last_print_time = time.ticks_ms()

    # I2C 设备扫描与 ID 验证
    i2c_scan_and_verify(i2c, I2C_ADDR)

    # 创建 ADT7410 驱动实例
    print("Initializing ADT7410 sensor at address 0x%02X..." % I2C_ADDR)
    adt = ADT7410(i2c, address=I2C_ADDR)

    # 初始化信息打印
    print("ADT7410 initialized successfully")
    print("Current temperature: %.4f C" % adt.temperature)
    print("Operation mode: %s" % adt.operation_mode)
    print("Resolution mode: %s" % adt.resolution_mode)
    print("Alert status: %s" % str(adt.alert_status))
    print("=" * 60)
    print("Entering main loop (Ctrl+C to exit)...\n")

    # ======================================== 主程序 ==============================================

    try:
        while True:
            current_time = time.ticks_ms()

            # 定时打印温度(低频,自动执行)
            if time.ticks_diff(current_time, last_print_time) >= PRINT_INTERVAL:
                print_temperature_detail(adt)
                last_print_time = current_time

            # --- 以下函数默认注释调用,可在 REPL 中手动执行 ---

            # test_operation_modes(adt)           # 遍历所有工作模式
            # test_resolution_modes(adt)          # 测试分辨率切换对比
            # test_comparator_mode(adt)            # 测试比较器模式与告警
            # test_boundary_thresholds(adt)        # 测试温度阈值边界值
            # test_invalid_operation_mode(adt)     # 测试无效操作模式异常
            # test_invalid_temperature_threshold(adt)  # 测试超范围温度阈值异常
            # test_invalid_hysteresis(adt)         # 测试超范围迟滞值异常
            # test_reset(adt)                      # 测试传感器复位
            # test_context_manager(i2c)            # 测试上下文管理器(将创建新实例)

            # 主循环节流
            await asyncio.sleep_ms(100)

    except KeyboardInterrupt:
        print("\nProgram interrupted by user")
    except OSError as e:
        print("Hardware communication error: %s" % str(e))
    except Exception as e:
        print("Unknown error: %s" % str(e))
    finally:
        print("Cleaning up resources...")
        adt.deinit()
        del adt
        print("Program exited")

if __name__ == '__main__':
    asyncio.run(main())

异步设计与使用

源状态:sync_source。本包归属当前异步仓库;原始实现的作者和许可证以源包元数据及 LICENSE 为准。协程入口应以 asyncio.run(main()) 启动。若类提供 start()/stop()、deinit() 或 aclose(),必须按其实际签名管理后台任务和资源,且在 finally 中清理。

API Async Matrix

API Level Async strategy Residual blocking Timeout/cancellation
ADT7410.alert_status not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410.comparator_mode not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410.critical_temperature not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410.deinit not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410.high_temperature not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410.hysteresis_temperature not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410.low_temperature not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410.operation_mode not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410.reset not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410.resolution_mode not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410.temperature not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410Async.alert_status_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410Async.comparator_mode_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410Async.critical_temperature_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410Async.deinit_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410Async.high_temperature_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410Async.hysteresis_temperature_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410Async.low_temperature_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410Async.operation_mode_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410Async.reset_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410Async.resolution_mode_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
ADT7410Async.temperature_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
SyncAdapterMixin.aclose not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
aclose not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
alert_status not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
alert_status_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
comparator_mode not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
comparator_mode_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
critical_temperature not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
critical_temperature_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
deinit not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
deinit_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
high_temperature not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
high_temperature_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
hysteresis_temperature not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
hysteresis_temperature_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
i2c_scan_and_verify not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
low_temperature not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
low_temperature_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
main not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
operation_mode not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
operation_mode_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
print_temperature_detail not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
reset not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
reset_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
resolution_mode not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
resolution_mode_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
temperature not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
temperature_async not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
test_boundary_thresholds not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
test_comparator_mode not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
test_context_manager not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
test_invalid_hysteresis not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
test_invalid_operation_mode not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
test_invalid_temperature_threshold not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
test_operation_modes not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
test_reset not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。
test_resolution_modes not_async_safe 直接委托来源同步 I2C 事务;事务内不让出 同步 I2C 事务可无限期或不可预期地阻塞事件循环 无事务内 timeout;取消仅在同步调用返回后生效;不得用于时延敏感协程。

Source Demo to Async Demo Mapping

Source sync step Source API/protocol action Async implementation Preserved output/error meaning Residual blocking
源包示例 code/main.py code/main.py 或本文快速开始 保留实际构造与调用;异常语义以运行时代码为准 存在

超时、取消、并发与残余阻塞

任何 await 不会自动使底层 I2C/SPI/UART/Pin 操作变为非阻塞。取消时应停止后台任务并在 finally 释放资源;没有实现超时参数的 API 不应被假定具有超时。协议命令、帧界限、ACK、静默间隔及错误含义只以当前实现和源示例可证明的内容为准。

Sync Adapter Blocking Budget

所有标记为 not_async_safe 的 API 都直接委托给来源实现中的一个或多个同步 I2C 事务;协程包装本身不在事务内部让出执行权。阻塞来源是 I2C.readfrom_mem、I2C.writeto_mem、I2C.readfrom 或 I2C.writeto。未在目标硬件、总线频率、从机时钟拉伸和错误恢复条件下测得可证实的最大事务时长,因此最大阻塞时间为“未验证”,不能承诺 deadline 或实时性。

这些 API 没有事务内 timeout,也不能在 I2C 调用进行时响应取消;任务取消只会在同步调用返回后的下一个 await 处生效。调用者应避免在时延敏感的任务、IRQ 或 PIO 回调中调用,并在同一 I2C 总线的并发访问上自行串行化。保留风险:慢设备、时钟拉伸、总线故障或驱动恢复都可能使事件循环阻塞;尚未进行硬件验证。

Hardware Acceptance

Level Evidence Not covered
Link 未实测:仅完成静态代码与文档取证。 总线/网络连接、设备身份响应。
Basic function 未实测。 一次真实业务 API 成功及结果正确性。
Complete business flow 未实测。 端到端设备、对端、供电、时序和异常恢复。

注意事项

类别 说明
并发 同一硬件实例应由调用方串行化;UART 额外遵守其并发契约。
阻塞 不把短同步总线访问或严格时序脉冲描述为真正可中断。
验收 文档生成不等于硬件验证;接入真实设备后分别记录三层验收证据。

版本记录

版本号 日期 作者 修改说明
1.0.0 2026-09-17 Jose D. Montoya 基于当前异步代码、来源包和许可证重新取证 README。

联系方式

请通过本仓库的 issue 或维护者渠道联系;包内元数据作者为:Jose D. Montoya。

许可协议

许可证声明:MIT。以下为本包 LICENSE 的逐字内容:

MIT License

Copyright (c) 2026 Jose D. Montoya

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.
文件列表
Name Size Type
LICENSE 1.0KB File
README.md 37.3KB Doc
code/__init__.py 934B Main
code/_gs_adt7410_adt7410.py 24.8KB Python
code/_gs_adt7410_i2c_helpers.py 15.9KB Python
code/adt7410_async.py 3.4KB Python
code/main.py 1.3KB Main
examples/main_sync.py 12.4KB Python
package.json 687B Conf