1006 lines
49 KiB
Python
1006 lines
49 KiB
Python
"""
|
||
ADS124S08 ADC 驱动模块 — 树莓派 5 用户空间 SPI 驱动
|
||
|
||
本模块实现了 ADS124S08 模数转换器（ADC）的核心功能：
|
||
- 寄存器读写操作
|
||
- 通过 GPIO 控制芯片上电时序的设备初始化
|
||
- PGA（可编程增益放大器）配置
|
||
- 输入多路复用器选择（单端或差分输入）
|
||
- 数据速率和转换模式设置
|
||
- DRDY（数据就绪）引脚处理
|
||
- 单次/连续转换模式
|
||
|
||
SPI 通信简介：
|
||
SPI（Serial Peripheral Interface，串行外设接口）是一种同步串行通信协议，
|
||
使用四根信号线：SCLK（时钟线）、MOSI（主设备输出/从设备输入）、
|
||
MISO（主设备输入/从设备输出）、CS（片选线，低电平有效）。
|
||
SPI 是全双工通信，主设备（树莓派）发送时钟信号的同时，主设备和从设备（ADC）
|
||
可以同时发送和接收数据。
|
||
|
||
引脚接线表（树莓派 5）：
|
||
- SPI 总线：/dev/spidev0.0（bus=0, device=0）
|
||
- DRDY 引脚（数据就绪指示，低电平表示有数据可读）：GPIO25
|
||
- 上电阶段 1 控制引脚（先拉高，给 ADC 供电的第一部分）：GPIO22、GPIO17
|
||
- 上电阶段 2 控制引脚（100ms 后拉高，给 ADC 供电的第二部分）：GPIO23、GPIO27
|
||
- 保持低电平引脚（初始化期间强制保持低电平）：GPIO24、GPIO18
|
||
|
||
为什么要分两步上电：
|
||
ADS124S08 芯片的模拟电源和数字电源需要按顺序启动，如果同时上电可能
|
||
导致芯片内部状态不确定。先启动第一部分电源（Stage 1），等待 100ms 让电源稳定后，
|
||
再启动第二部分电源（Stage 2），可以确保芯片可靠启动。
|
||
|
||
上电时序流程：
|
||
1. 将阶段 1 的 GPIO 引脚拉高（输出高电平），开启第一阶段供电，等待 100ms
|
||
2. 将阶段 2 的 GPIO 引脚拉高，开启第二阶段供电
|
||
3. 发送复位命令，让 ADC 芯片重新启动
|
||
4. 配置寄存器（PGA 增益、输入多路复用器、数据速率等）
|
||
|
||
ADC 芯片数据手册参考链接：
|
||
https://www.ti.com.cn/product/cn/ADS124S08?keyMatch=ADS124S08&tisearch=universal_search
|
||
|
||
"""
|
||
|
||
|
||
# 从 __future__ 模块导入 annotations 特性。
|
||
# 这允许在方法的类型注解中使用字符串形式（如 -> "SomeClass"），而不是直接引用类名，
|
||
# 从而避免在类定义内部引用自身或其他尚未完全定义的类时出现 NameError 错误。
|
||
from __future__ import annotations
|
||
|
||
# 从 Python 标准库 signal 模块导入 pause 函数。
|
||
# pause() 会让程序进入等待状态，直到接收到信号（如 SIGINT，即按 Ctrl+C）才会继续执行。
|
||
# 在这里用于在主程序中保持程序持续运行，不退出。
|
||
from signal import pause
|
||
|
||
# 导入 spidev 库。spidev 是树莓派上用户空间操作 SPI 总线的 Python 库，
|
||
# 它封装了 Linux SPI 设备文件（如 /dev/spidev0.0）的 ioctl 系统调用，
|
||
# 让我们可以方便地通过 SPI 协议与外部设备（如 ADS124S08 ADC）进行数据收发。
|
||
import spidev
|
||
|
||
# 从 gpiozero 库导入 DigitalOutputDevice（数字输出设备）和 Button（按钮/输入设备）。
|
||
# DigitalOutputDevice 用于控制 GPIO 引脚输出高电平或低电平，比如控制 ADC 芯片的电源开关。
|
||
# Button 用于检测 GPIO 引脚的电平变化（从高到低或从低到高），
|
||
# 在这里用于检测 ADC 的 DRDY（数据就绪）引脚是否变低。
|
||
from gpiozero import DigitalOutputDevice, Button
|
||
|
||
# 导入整个 gpiozero 库（上面导入的是其中的特定类，这里导入整个库以备需要其他功能）。
|
||
import gpiozero
|
||
|
||
# 导入 Python 标准库中的 time 模块，用于执行延时（sleep）、获取当前时间等操作。
|
||
# 在本驱动中，time.sleep() 用于在 GPIO 上电步骤之间等待电源稳定，
|
||
# 以及在等待 ADC 完成转换时等待足够的时间。
|
||
import time
|
||
|
||
# =============================================================================
|
||
# ADS124S08 命令码定义
|
||
# 下面这些是发给 ADC 芯片的命令字节，每个命令都是一个 1 字节（8 位）的值。
|
||
# 使用时通过 SPI 的 MOSI 线发送给 ADC，ADC 收到后执行对应操作。
|
||
# =============================================================================
|
||
# 空操作（No OPeration），发给 ADC 后它什么也不做，通常用于占位或填充 SPI 时钟周期
|
||
ADS124S08_CMD_NOP = 0x00
|
||
# 唤醒命令，让处于休眠（断电）模式的 ADC 芯片恢复到正常工作状态
|
||
ADS124S08_CMD_WAKEUP = 0x02
|
||
# 断电命令（PoWeR DoWN），让 ADC 芯片进入低功耗休眠模式，以节省电能
|
||
ADS124S08_CMD_PWRDWN = 0x04
|
||
# 复位命令（RESET），让 ADC 芯片重新启动，所有寄存器恢复到默认值
|
||
ADS124S08_CMD_RESET = 0x06
|
||
# 启动转换命令（START），告诉 ADC 开始进行模数转换
|
||
ADS124S08_CMD_START = 0x08
|
||
# 停止转换命令（STOP），告诉 ADC 停止当前的模数转换
|
||
ADS124S08_CMD_STOP = 0x0a
|
||
# 系统失调校准命令（SYstem OCal Calibration），对整个系统进行偏移量校准
|
||
ADS124S08_CMD_SYOCAL = 0x16
|
||
# 系统增益校准命令（SYstem Gain Calibration），对整个系统进行增益校准
|
||
ADS124S08_CMD_SYGCAL = 0x17
|
||
# 自失调校准命令（SelF OCal Calibration），只对 ADC 自身进行偏移量校准
|
||
ADS124S08_CMD_SFOCAL = 0x19
|
||
# 读取数据命令（Read DATA），告诉 ADC 把最新的转换结果发送回来
|
||
ADS124S08_CMD_RDATA = 0x12
|
||
# 读寄存器命令（Read REGister），后面需要跟寄存器地址和要读取的寄存器数量
|
||
ADS124S08_CMD_RREG = 0x20
|
||
# 写寄存器命令（Write REGister），后面需要跟寄存器地址和要写入的数据
|
||
# 注意：RREG 和 WREG 的最高位不同（0x20 vs 0x40），这是 ADC 用来区分读写操作的标志
|
||
ADS124S08_CMD_WREG = 0x40
|
||
|
||
# =============================================================================
|
||
# ADS124S08 寄存器地址定义
|
||
# 寄存器是 ADC 芯片内部的一些存储单元，每个寄存器有 1 字节（8 位）宽度。
|
||
# 我们可以通过 SPI 发送 RREG（读寄存器）或 WREG（写寄存器）命令来读取或修改它们。
|
||
# 寄存器控制着 ADC 的各种工作参数，比如选择哪个输入通道、设置放大倍数、选择数据速率等。
|
||
# =============================================================================
|
||
# 芯片 ID 寄存器（出厂固化），只读，存放芯片型号和版本号，可以用来验证 SPI 通信是否正常
|
||
ADS124S08_ID_REG = 0x00
|
||
# 状态寄存器（STATUS），存放 ADC 的工作状态标志，如是否发生过上电复位、是否有数据就绪等
|
||
ADS124S08_STATUS = 0x01
|
||
# 输入多路复用器寄存器（INPUT MUX），控制选择哪个模拟输入引脚接到 ADC 内部
|
||
ADS124S08_INPUT_MUX = 0x02
|
||
# PGA（可编程增益放大器）寄存器，控制是否启用前置放大以及放大多少倍（1~128 倍）
|
||
ADS124S08_PGA = 0x03
|
||
# 数据速率寄存器（DATA RATE），控制 ADC 每秒采样多少次（2.5 SPS ~ 4000 SPS）
|
||
ADS124S08_DATA_RATE = 0x04
|
||
# 参考电压寄存器（REF），配置参考电压的来源和缓冲器
|
||
ADS124S08_REF = 0x05
|
||
# 激励电流源幅度寄存器（IDAC MAGnitude），设置恒流源电流大小
|
||
ADS124S08_IDACMAG = 0x06
|
||
# 激励电流源输出引脚选择寄存器（IDAC MUX），选择恒流源接到哪个 AIN 引脚
|
||
ADS124S08_IDACMUX = 0x07
|
||
# 偏置电压寄存器（VBIAS），配置是否在输入引脚上叠加一个偏置电压
|
||
ADS124S08_VBIAS = 0x08
|
||
# 系统控制寄存器（SYS），控制 CRC 校验等系统级功能
|
||
ADS124S08_SYS = 0x09
|
||
# 失调校准寄存器 0（OFfset CALibration 0），用于细调 ADC 的零偏（低 8 位）
|
||
ADS124S08_OFCAL0 = 0x0a
|
||
# 失调校准寄存器 1（OFfset CALibration 1），用于细调 ADC 的零偏（中间 8 位）
|
||
ADS124S08_OFCAL1 = 0x0b
|
||
# 失调校准寄存器 2（OFfset CALibration 2），用于细调 ADC 的零偏（高 8 位）
|
||
ADS124S08_OFCAL2 = 0x0c
|
||
# 满量程校准寄存器 0（Full SCale CALibration 0），用于校准 ADC 的增益误差（低 8 位）
|
||
ADS124S08_FSCAL0 = 0x0d
|
||
# 满量程校准寄存器 1（Full SCale CALibration 1），用于校准 ADC 的增益误差（中间 8 位）
|
||
ADS124S08_FSCAL1 = 0x0e
|
||
# 满量程校准寄存器 2（Full SCale CALibration 2），用于校准 ADC 的增益误差（高 8 位）
|
||
ADS124S08_FSCAL2 = 0x0f
|
||
# GPIO 数据寄存器（GPIO DATa），通过 SPI 读写 ADC 芯片上的通用输入输出引脚电平
|
||
ADS124S08_GPIODAT = 0x10
|
||
# GPIO 配置寄存器（GPIO CONfiguration），配置 ADC 芯片上 GPIO 引脚的方向（输入/输出）
|
||
ADS124S08_GPIOCON = 0x11
|
||
|
||
# =============================================================================
|
||
# ADS124S08 模拟输入通道号定义
|
||
# ADS124S08 有 12 个模拟输入引脚（AIN0 ~ AIN11），可以通过 INPUT_MUX 寄存器
|
||
# 选择连接到 ADC 内部的哪个通道。此外还有一个 AINCOM（公共端）引脚，
|
||
# 用于单端测量时作为参考地（负端）。
|
||
# =============================================================================
|
||
# 模拟输入引脚 0，地址编码为 0x00（二进制 0000）
|
||
ADS124S08_AIN0 = 0x00
|
||
# 模拟输入引脚 1，地址编码为 0x01（二进制 0001）
|
||
ADS124S08_AIN1 = 0x01
|
||
# 模拟输入引脚 2，地址编码为 0x02（二进制 0010）
|
||
ADS124S08_AIN2 = 0x02
|
||
# 模拟输入引脚 3，地址编码为 0x03（二进制 0011）
|
||
ADS124S08_AIN3 = 0x03
|
||
# 模拟输入引脚 4，地址编码为 0x04（二进制 0100）
|
||
ADS124S08_AIN4 = 0x04
|
||
# 模拟输入引脚 5，地址编码为 0x05（二进制 0101）
|
||
ADS124S08_AIN5 = 0x05
|
||
# 模拟输入引脚 6，地址编码为 0x06（二进制 0110）
|
||
ADS124S08_AIN6 = 0x06
|
||
# 模拟输入引脚 7，地址编码为 0x07（二进制 0111）
|
||
ADS124S08_AIN7 = 0x07
|
||
# 模拟输入引脚 8，地址编码为 0x08（二进制 1000）
|
||
ADS124S08_AIN8 = 0x08
|
||
# 模拟输入引脚 9，地址编码为 0x09（二进制 1001）
|
||
ADS124S08_AIN9 = 0x09
|
||
# 模拟输入引脚 10，地址编码为 0x0a（二进制 1010）
|
||
ADS124S08_AIN10 = 0x0a
|
||
# 模拟输入引脚 11，地址编码为 0x0b（二进制 1011）
|
||
ADS124S08_AIN11 = 0x0b
|
||
# 公共端引脚（AINCOM，地址编码 0x0c），在单端测量时作为负输入端（参考地），
|
||
# 即测量 AINx 相对于 AINCOM 的电压。在差分配置下，AINCOM 也可以作为一个普通的输入端。
|
||
ADS124S08_AINCOM = 0x0c
|
||
|
||
|
||
# =============================================================================
|
||
# 定义 ADS124S08 类，封装了 ADC 芯片的所有操作
|
||
# =============================================================================
|
||
|
||
# 定义一个名为 ADS124S08 的类（class），类相当于一个模板，通过它可以创建 ADC 对象实例。
|
||
# 每个实例有自己的 SPI 连接、GPIO 引脚设置等，可以独立控制一块 ADC 芯片。
|
||
class ADS124S08:
|
||
"""ADS124S08 ADC 驱动类（用户空间驱动）
|
||
|
||
这个类封装了对 ADS124S08 模数转换器的所有操作，包括：
|
||
- SPI 总线的打开和关闭
|
||
- GPIO 电源控制（分步上电）
|
||
- 寄存器读写
|
||
- 配置增益、输入通道、数据速率等
|
||
- 读取转换结果
|
||
|
||
基本用法示例：
|
||
adc = ADS124S08(bus=0, device=0) # 创建 ADC 对象，连接到 SPI0.0
|
||
adc.reset() # 复位 ADC 芯片
|
||
val = adc.read_channel(0) # 读取通道 0 的电压值
|
||
|
||
参数说明：
|
||
- bus/device：SPI 总线和设备号，例如 bus=0, device=0 对应 /dev/spidev0.0
|
||
- max_speed_hz：SPI 通信时钟频率，单位赫兹（Hz），影响通信速度
|
||
- mode：SPI 工作模式（0~3），由时钟极性（CPOL）和时钟相位（CPHA）组合决定
|
||
- reset_pin：可选的复位引脚（BCM GPIO 编号），如果提供则通过 GPIO 硬件复位（需要 RPi.GPIO 库）
|
||
"""
|
||
|
||
def __init__(self):
|
||
"""初始化 ADC 对象，完成以下步骤：
|
||
1. 设置 SPI 总线和设备号（默认 bus=0, device=0，对应 /dev/spidev0.0）
|
||
2. 打开 SPI 设备文件，建立与 ADC 芯片的通信连接
|
||
3. 配置 SPI 通信参数（时钟频率 1MHz，模式 1）
|
||
4. 设置 GPIO 引脚编号（DRDY、上电控制、保持低电平）
|
||
5. 初始化 GPIO 引脚的电平状态
|
||
6. 分两步给 ADC 上电（Stage 1 -> 100ms 等待 -> Stage 2）
|
||
7. 发送复位命令，让 ADC 恢复到默认状态
|
||
8. 读取所有寄存器值，验证 SPI 通信是否正常
|
||
9. 清除上电复位标志
|
||
10. 配置参考电压源
|
||
|
||
注意：构造函数不需要额外参数，所有配置使用默认值。
|
||
如果要修改配置，可以在创建对象后调用对应的 set_xxx() 方法。
|
||
"""
|
||
|
||
# -----------------------------------------------------------------------
|
||
# SPI 总线配置
|
||
# -----------------------------------------------------------------------
|
||
# 设置 SPI 总线编号为 0（树莓派有 2 个 SPI 总线：SPI0 和 SPI1）
|
||
self.bus = 0
|
||
# 设置 SPI 设备编号为 0（每个 SPI 总线上可以有多个设备，通过片选引脚 CS 区分）
|
||
self.device = 0
|
||
# 创建一个 SpiDev 对象，这是 spidev 库提供的 SPI 通信接口
|
||
self.spi = spidev.SpiDev()
|
||
# 尝试打开 SPI 设备文件（在 Linux 中对应 /dev/spidev0.0 这个设备文件）
|
||
try:
|
||
self.spi.open(self.bus, self.device)
|
||
# 如果 SPI 设备文件不存在（例如内核没加载 SPI 驱动，或设备号不对），会抛出 FileNotFoundError
|
||
except FileNotFoundError as e:
|
||
# 抛出更清晰的异常信息，告诉用户是哪个 SPI 设备打开失败了
|
||
raise Exception(f"SPI device /dev/spidev{self.bus}.{self.device} not found: {e}")
|
||
|
||
# 设置 SPI 通信时钟频率为 1 MHz（1,000,000 Hz），
|
||
# 这是主设备（树莓派）和从设备（ADC）之间数据传输的速率。
|
||
# 频率越高通信越快，但信号质量可能下降。1 MHz 是 ADC 芯片支持的常用频率。
|
||
self.spi.max_speed_hz = 1_000_000 # 1 MHz 默认值
|
||
# 设置 SPI 模式为 0b01（即模式 1），
|
||
# SPI 有 4 种模式（0~3），由时钟极性（CPOL）和时钟相位（CPHA）决定：
|
||
# 模式 1 = CPOL=0, CPHA=1：空闲时时钟为低电平，在下降沿采样数据
|
||
self.spi.mode = 0b01 # 默认使用 SPI 模式 1
|
||
# 设置 CRC 校验默认关闭（由 set_crc() 方法控制）
|
||
self.en_crc = False # 默认禁用 CRC 校验
|
||
|
||
# -----------------------------------------------------------------------
|
||
# GPIO 引脚配置
|
||
# -----------------------------------------------------------------------
|
||
# DRDY 引脚（Data Ready，数据就绪），连接 ADC 的 DRDY 引脚到树莓派的 GPIO25。
|
||
# 当 ADC 完成一次转换且有新数据可读时，DRDY 引脚会从高电平变为低电平。
|
||
self.drdy_pin = 25
|
||
|
||
# 上电阶段 1 的 GPIO 引脚列表（GPIO22 和 GPIO17），
|
||
# 这两个引脚在初始化时先被拉高（输出高电平），开启 ADC 的第一部分电源
|
||
self.power_stage1 = [22, 17]
|
||
# 上电阶段 2 的 GPIO 引脚列表（GPIO24 和 GPIO27），
|
||
# 这两个引脚在阶段 1 完成 100ms 后被拉高，开启 ADC 的第二部分电源
|
||
self.power_stage2 = [24, 27]
|
||
# 保持低电平的 GPIO 引脚列表（GPIO23 和 GPIO18），
|
||
# 这些引脚在整个初始化期间被强制保持为低电平（输出低电平）
|
||
self.gpio_hold_low = [23, 18]
|
||
|
||
# 创建一个 Button 对象来监控 DRDY 引脚。
|
||
# gpiozero 的 Button 类默认检测引脚从高电平变为低电平（下降沿触发），
|
||
# 这正好对应 DRDY 引脚"数据就绪时变低"的行为。
|
||
# 如果 drdy_pin 为 None，则 self._drdy_pin 也设为 None（不使用 DRDY 引脚检测）。
|
||
self._drdy_pin = Button(self.drdy_pin) if self.drdy_pin is not None else None
|
||
|
||
# -----------------------------------------------------------------------
|
||
# GPIO 初始化 — 将所有控制引脚设为初始状态
|
||
# -----------------------------------------------------------------------
|
||
# 创建一个空字典，用于存储所有 GPIO 引脚对应的 DigitalOutputDevice 对象，
|
||
# 方便后续通过引脚编号快速找到对应的设备对象来控制其电平。
|
||
self._gpio_devices = {}
|
||
# 遍历 power_stage1、power_stage2 和 gpio_hold_low 中的所有引脚编号，
|
||
# 用 set() 去重，确保每个引脚只创建一次设备对象。
|
||
for p in set(self.power_stage1 + self.power_stage2 + self.gpio_hold_low):
|
||
# 尝试为每个引脚创建一个 DigitalOutputDevice 对象，初始电平设为 False（低电平）
|
||
try:
|
||
self._gpio_devices[p] = DigitalOutputDevice(p, initial_value=False)
|
||
# 如果创建失败（例如引脚被占用或 GPIO 权限不足），则跳过该引脚
|
||
except Exception:
|
||
pass
|
||
|
||
# 确保"保持低电平"的引脚确实处于低电平状态（再次确认）
|
||
for p in self.gpio_hold_low:
|
||
dev = self._gpio_devices.get(p)
|
||
if dev:
|
||
dev.off()
|
||
|
||
# -----------------------------------------------------------------------
|
||
# 上电阶段 1：先给 ADC 提供第一部分电源
|
||
# 为什么要分两步：ADS124S08 的模拟和数字部分需要按顺序供电，
|
||
# 如果同时上电可能导致内部电路状态不确定。先让第一部分稳定，再启动第二部分。
|
||
# -----------------------------------------------------------------------
|
||
for p in self.power_stage1:
|
||
dev = self._gpio_devices.get(p)
|
||
if dev:
|
||
# 调用 on() 方法将引脚设为高电平（输出 3.3V），开启第一路供电
|
||
dev.on()
|
||
# 等待 100 毫秒（0.1 秒），让第一部分电源稳定下来，消除电源波动
|
||
time.sleep(0.100)
|
||
|
||
# -----------------------------------------------------------------------
|
||
# 上电阶段 2：给 ADC 提供第二部分电源
|
||
# -----------------------------------------------------------------------
|
||
for p in self.power_stage2:
|
||
dev = self._gpio_devices.get(p)
|
||
if dev:
|
||
# 将引脚设为高电平，开启第二路供电
|
||
dev.on()
|
||
# 再次等待 100 毫秒，等待 ADC 芯片内部电源管理电路完成初始化
|
||
time.sleep(0.100)
|
||
# 发送复位命令，让 ADC 芯片重新启动，所有寄存器恢复到数据手册规定的默认值
|
||
self.reset()
|
||
# 等待 100 毫秒，让复位完成（复位后芯片内部需要时间重新初始化）
|
||
time.sleep(0.100)
|
||
# 通过 SPI 发送 19 个字节来读取所有寄存器（地址 0x00 ~ 0x11，共 18 个）：
|
||
# - 第 1 个字节 = RREG 命令（0x20 | 0x01），表示从地址 0x01 开始读（实际第一个字节是地址 0x00）
|
||
# - 第 2 个字节 = 0x10（十进制 16），表示要连续读取 17 个寄存器（寄存器数量 = 该值 + 1）
|
||
# - 第 3~19 个字节 = 填充 0x00，用于给 SPI 提供时钟信号以读取返回数据
|
||
rx = self.spi.xfer2([ADS124S08_CMD_RREG | (0x01 & 0xFF), 0x10] + [0x00]*17)
|
||
# 复位后各寄存器的默认值列表（从数据手册获得），用于验证 SPI 通信是否正确
|
||
default_regs = [0x80, 0x01, 0x00, 0x14, 0x10, 0x00, 0xff, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00]
|
||
# 如果收到的数据长度是 19 字节，说明通信正常（发送 3 字节收到 3 字节，SPI 是全双工的）
|
||
if len(rx) == 19:
|
||
# 将读取到的寄存器值（从 rx[2] 开始，前两个字节是命令的回显）与默认值逐一对比
|
||
for i, (actual, expected) in enumerate(zip(rx[2:], default_regs)):
|
||
# 如果某个寄存器的值与期望值不符，说明 SPI 通信有问题或芯片工作异常
|
||
if actual != expected:
|
||
# 抛出异常，报告是哪个寄存器不匹配
|
||
raise Exception(f"Register {i} mismatch: expected 0x{expected:02x}, got 0x{actual:02x}")
|
||
# 清除 STATUS 寄存器中的上电复位（Power-On Reset）标志位，
|
||
# 告诉芯片"我们已经知道发生过上电复位了"，这样下次就可以通过检查这个标志来判断是否掉电重启过
|
||
self.clear_por()
|
||
# 配置参考电压源：
|
||
# - en_monitor=0：禁用参考电压监控
|
||
# - en_bufp=1：使能正参考电压缓冲器（提高带负载能力）
|
||
# - en_bufn=1：使能负参考电压缓冲器
|
||
# - refsel=2：选择内部参考电压（2.5V）
|
||
# - refcon=1：内部参考电压开启（但在待机模式下可以关闭以省电）
|
||
self.set_ref(en_monitor=0, en_bufp=1, en_bufn=1, refsel=2, refcon=1)
|
||
|
||
def close(self) -> None:
|
||
"""关闭并清理所有资源，释放 SPI 总线和 GPIO 引脚。
|
||
|
||
在程序结束或不再需要使用 ADC 时调用此方法，确保：
|
||
1. 关闭 SPI 设备文件，释放 SPI 总线资源
|
||
2. 将所有 GPIO 控制引脚设置为低电平
|
||
3. 关闭并释放所有 GPIO 设备对象
|
||
4. 关闭 DRDY 引脚检测对象
|
||
"""
|
||
# 使用 try...finally 结构，无论 SPI 关闭是否成功，都会执行后续的清理操作
|
||
try:
|
||
# 检查 SPI 对象是否存在（防止重复关闭）
|
||
if self.spi:
|
||
# 关闭 SPI 设备文件 /dev/spidev0.0，释放总线资源
|
||
self.spi.close()
|
||
finally:
|
||
# 将 SPI 对象设为 None，标记为已关闭，防止后续误用
|
||
self.spi = None # type: ignore
|
||
# 清理所有 gpiozero 创建的 GPIO 设备对象
|
||
if hasattr(self, '_gpio_devices'):
|
||
# 遍历字典中所有 GPIO 设备
|
||
for dev in self._gpio_devices.values():
|
||
try:
|
||
# 先将引脚设为低电平（关断电源）
|
||
dev.off()
|
||
# 关闭并释放 GPIO 设备对象
|
||
dev.close()
|
||
except Exception:
|
||
# 如果关闭失败（例如设备已被其他程序占用），静默跳过
|
||
pass
|
||
# 检查 DRDY 引脚对象是否存在
|
||
if self._drdy_pin is not None:
|
||
try:
|
||
# 关闭 DRDY 引脚检测对象
|
||
self._drdy_pin.close()
|
||
except Exception:
|
||
pass
|
||
|
||
def reset(self) -> None:
|
||
"""复位 ADC 芯片。
|
||
|
||
通过 SPI 向 ADC 发送复位命令（RESET = 0x06），让芯片重新启动。
|
||
复位后所有寄存器恢复为数据手册中的默认值，等效于给芯片断电再重新上电的效果。
|
||
"""
|
||
# 通过 SPI 发送复位命令字节 0x06，让 ADC 芯片执行硬件复位
|
||
self.write_cmd(ADS124S08_CMD_RESET)
|
||
# 根据数据手册要求，复位后需要等待一段时间让芯片内部完成初始化。
|
||
# 这里等待 10 毫秒（0.01 秒），确保复位操作完成。
|
||
time.sleep(0.01)
|
||
|
||
def write_cmd(self, cmd: int) -> None:
|
||
"""通过 SPI 向 ADC 发送单字节命令。
|
||
|
||
这是最底层的命令发送函数，只发送一个字节。
|
||
常用于发送 NOP（空操作）、RESET（复位）、START（启动转换）、STOP（停止转换）等命令。
|
||
|
||
参数:
|
||
cmd: 要发送的命令字节（0~255 的整数），例如 ADS124S08_CMD_RESET = 0x06
|
||
"""
|
||
# 通过 SPI 的 xfer2 方法发送 1 个字节。
|
||
# xfer2 是 spidev 库的全双工传输函数，会同时从 MISO 线接收相同数量的字节。
|
||
# cmd & 0xFF 确保只取低 8 位，防止数值超过一个字节。
|
||
self.spi.xfer2([cmd & 0xFF])
|
||
|
||
def write_reg(self, reg: int, data: int) -> None:
|
||
"""向 ADC 的指定寄存器写入数据（1 个寄存器）。
|
||
|
||
通过 SPI 发送 3 个字节：
|
||
- 第 1 字节：WREG 命令码（0x40），与寄存器地址按位或（|）组合
|
||
- 第 2 字节：0x00，表示只写 1 个寄存器（寄存器数量 = 该值）
|
||
- 第 3 字节：要写入寄存器的数据
|
||
|
||
参数:
|
||
reg: 寄存器地址（0x00 ~ 0x11），例如 ADS124S08_PGA = 0x03
|
||
data: 要写入的数据（0~255），按寄存器的位定义填充
|
||
"""
|
||
# 通过 SPI 发送 3 个字节：
|
||
# [0x40 | reg] 把 WREG 命令码和寄存器地址组合成一个字节
|
||
# [0x00] 表示要写的寄存器数量减 1（0 表示写 1 个）
|
||
# [data & 0xFF] 是要写入寄存器的数据，& 0xFF 确保不超过一个字节
|
||
self.spi.xfer2([ADS124S08_CMD_WREG | (reg & 0xFF), 0x00, data & 0xFF])
|
||
|
||
def read_reg(self, reg: int) -> int:
|
||
"""读取 ADC 指定寄存器的值（1 个寄存器）。
|
||
|
||
通过 SPI 发送 3 个字节，同时收到 3 个字节：
|
||
- 发送的第 1 字节：RREG 命令码（0x20），与寄存器地址按位或组合
|
||
- 发送的第 2 字节：0x00，表示只读 1 个寄存器
|
||
- 发送的第 3 字节：0x00（填充字节，用于产生 SPI 时钟信号让 ADC 把数据发送回来）
|
||
- 接收的第 3 字节：寄存器的当前值
|
||
|
||
参数:
|
||
reg: 寄存器地址（0x00 ~ 0x11）
|
||
|
||
返回:
|
||
寄存器的当前值（0~255 的整数）
|
||
"""
|
||
# RREG 命令格式：[命令码 | 寄存器地址, 寄存器数量-1, 填充字节]
|
||
# 其中 0x20 是 RREG 命令的基地址，0x00 表示读 1 个寄存器
|
||
rx = self.spi.xfer2([ADS124S08_CMD_RREG | (reg & 0xFF), 0x00, 0x00])
|
||
# 检查接收到的数据长度是否足够（至少 3 字节），防止 SPI 通信异常
|
||
if len(rx) < 3:
|
||
raise Exception("Short SPI read from device")
|
||
# 返回第 3 个字节（索引 2），即寄存器的值，& 0xFF 确保只取低 8 位
|
||
return rx[2] & 0xFF
|
||
|
||
def set_crc(self, en: bool) -> None:
|
||
"""启用或禁用 ADC 通信的 CRC 校验功能。
|
||
|
||
CRC（循环冗余校验）是一种数据校验方法，用于检测 SPI 通信过程中数据是否被干扰。
|
||
启用后，ADC 在发送数据时会附加一个 CRC 校验字节，接收方根据数据重新计算 CRC，
|
||
如果与收到的 CRC 不一致，说明通信发生了错误。
|
||
|
||
参数:
|
||
en: True 表示启用 CRC 校验，False 表示禁用
|
||
"""
|
||
# 在 Python 对象中记录 CRC 是否启用的状态
|
||
self.en_crc = en
|
||
# 先读取 SYS（系统控制）寄存器的当前值
|
||
val = self.read_reg(ADS124S08_SYS)
|
||
if en:
|
||
# 如果要启用 CRC：将 SYS 寄存器的 bit 1（二进制 00000010）置 1
|
||
# 按位或运算（|=）：要置 1 的位写 1，其他位保持不变
|
||
val |= 0b00000010 # 设置 CRC 使能位
|
||
else:
|
||
# 如果要禁用 CRC：将 SYS 寄存器的 bit 1（二进制 00000010）清 0
|
||
# 先取反（~），然后按位与（&=）：要清 0 的位写 0，其他位保持不变
|
||
val &= ~0b00000010 # 清除 CRC 使能位
|
||
# 将修改后的值写回 SYS 寄存器
|
||
self.write_reg(ADS124S08_SYS, val)
|
||
|
||
def _calculate_crc(self, data_bytes: list[int]) -> int:
|
||
"""计算数据字节的 CRC-8-ATM (HEC) 校验值。
|
||
|
||
这是 CRC-8-ATM 标准（也称为 HEC，Header Error Control），
|
||
使用多项式 x^8 + x^2 + x + 1（对应二进制 0x07）。
|
||
ADS124S08 芯片也使用同样的 CRC 算法，所以我们需要用同样的算法
|
||
计算数据的 CRC，然后与芯片发送过来的 CRC 字节比较，以验证数据的完整性。
|
||
|
||
参数:
|
||
data_bytes: 要计算 CRC 的数据字节列表（每个元素 0~255）
|
||
|
||
返回:
|
||
计算出的 CRC 值（0~255 的整数）
|
||
"""
|
||
# CRC 初始值为 0
|
||
crc = 0
|
||
# CRC-8-ATM 的多项式（生成多项式），二进制为 00000111，即 x^8 + x^2 + x + 1
|
||
poly = 0x07 # CRC-8-ATM 多项式
|
||
# 遍历每个数据字节
|
||
for byte in data_bytes:
|
||
# 将当前字节与 CRC 值按位异或（XOR），把当前字节"加入"CRC 计算
|
||
crc ^= byte
|
||
# 对每个字节的 8 个位逐位处理
|
||
for _ in range(8):
|
||
# 检查 CRC 的最高位（bit 7）是否为 1
|
||
if crc & 0x80:
|
||
# 如果最高位为 1：左移一位，然后与多项式异或（做多项式除法）
|
||
crc = (crc << 1) ^ poly
|
||
else:
|
||
# 如果最高位为 0：直接左移一位（相当于多项式除法的商为 0）
|
||
crc <<= 1
|
||
# 返回低 8 位作为最终的 CRC 值（& 0xFF 确保结果在 0~255 范围内）
|
||
return crc & 0xFF
|
||
|
||
def cmd_read_data(self) -> int:
|
||
"""主动读取 ADC 的转换结果（通过发送 RDATA 命令）。
|
||
|
||
这个方法向 ADC 发送 RDATA（读取数据）命令，然后读取 3 个字节的转换数据。
|
||
ADC 输出的数据是 24 位有符号整数，以大端（big-endian）格式排列，
|
||
即第一个字节是最高位（MSB），第三个字节是最低位（LSB）。
|
||
|
||
如果启用了 CRC 校验，还会多读一个 CRC 字节并进行校验。
|
||
|
||
返回:
|
||
24 位有符号整数表示的 ADC 转换原始值（范围：-8388608 ~ 8388607）
|
||
"""
|
||
# 如果启用了 CRC 校验，需要多发送和接收 1 个字节（CRC 字节）
|
||
if self.en_crc:
|
||
# 通过 SPI 发送 5 个字节：
|
||
# - 第 1 字节：RDATA 命令（0x12），告诉 ADC 把转换结果发回来
|
||
# - 第 2~4 字节：填充 0x00，用于产生 SPI 时钟，让 ADC 把 24 位数据发回来
|
||
# - 第 5 字节：填充 0x00，用于产生时钟让 ADC 把 CRC 字节发回来
|
||
rx = self.spi.xfer2([ADS124S08_CMD_RDATA, 0x00, 0x00, 0x00, 0x00])
|
||
# 检查收到的数据是否够 5 个字节
|
||
if len(rx) < 5:
|
||
raise Exception("Short SPI read from device")
|
||
# 合并 3 个数据字节为 24 位整数（大端格式）：
|
||
# 第 1 个字节（rx[1]）左移 16 位作为最高 8 位
|
||
# 第 2 个字节（rx[2]）左移 8 位作为中间 8 位
|
||
# 第 3 个字节（rx[3]）直接作为最低 8 位
|
||
data = (rx[1] << 16) | (rx[2] << 8) | rx[3]
|
||
# 第 5 个字节（rx[4]）是芯片计算的 CRC 校验值
|
||
crc_received = rx[4] & 0xFF
|
||
# 对收到的 3 个数据字节重新计算 CRC，与芯片发送的 CRC 比较
|
||
crc_calculated = self._calculate_crc([rx[1], rx[2], rx[3]])
|
||
# 如果计算出的 CRC 与收到的 CRC 不一致，说明数据传输过程中发生了错误
|
||
if crc_calculated != crc_received:
|
||
raise Exception(f"CRC mismatch: calculated 0x{crc_calculated:02x}, received 0x{crc_received:02x}, data: 0x{data:06x}")
|
||
# CRC 校验通过，将数据赋给 val
|
||
val = data
|
||
else:
|
||
# 未启用 CRC 校验，发送 4 个字节（少一个 CRC 字节）：
|
||
# - 第 1 字节：RDATA 命令（0x12）
|
||
# - 第 2~4 字节：填充 0x00，用于产生 SPI 时钟读取 24 位数据
|
||
rx = self.spi.xfer2([ADS124S08_CMD_RDATA, 0x00, 0x00, 0x00])
|
||
# 检查收到的数据是否够 4 个字节
|
||
if len(rx) < 4:
|
||
raise Exception("Short SPI read from device")
|
||
# 合并 3 个数据字节为 24 位整数（大端格式）
|
||
val = (rx[1] << 16) | (rx[2] << 8) | rx[3]
|
||
# 被注释掉的行：原来可能只取低 16 位（只使用 16 位分辨率），但实际使用了完整的 24 位
|
||
# val = (rx[1] << 16) | (rx[2] << 8) | 0x00
|
||
# 处理负数（符号扩展）：如果最高位（bit 23）为 1，说明是负数
|
||
if val & 0x800000:
|
||
# 将 24 位有符号数转换为 Python 的有符号整数：
|
||
# 减去 2^24（即 16777216），得到负数
|
||
return val - (1 << 24)
|
||
# 如果是正数，直接返回
|
||
return val
|
||
|
||
def drdy_read_data(self) -> int:
|
||
"""等待 DRDY 引脚变低后，直接读取 ADC 转换结果（不发送 RDATA 命令）。
|
||
|
||
当 ADC 完成一次转换后，DRDY 引脚会自动变为低电平，表示数据已就绪。
|
||
此时不需要发送 RDATA 命令，直接发送 3 个（或 4 个，含 CRC）填充字节
|
||
来产生 SPI 时钟，ADC 就会把最新的转换结果发送回来。
|
||
这种方法比 cmd_read_data() 更高效，适合连续采样场景。
|
||
|
||
注意：此方法不主动等待 DRDY 变低，调用者需要确保在调用此方法前
|
||
DRDY 引脚已经变为低电平（即数据已就绪）。
|
||
|
||
返回:
|
||
24 位有符号整数表示的 ADC 转换原始值（范围：-8388608 ~ 8388607）
|
||
"""
|
||
# 如果启用了 CRC 校验
|
||
if self.en_crc:
|
||
# 发送 4 个填充字节（不需要 RDATA 命令，DRDY 变低表示数据已就绪）：
|
||
# 第 1~3 字节用于产生 SPI 时钟读取 24 位数据
|
||
# 第 4 字节用于读取 CRC
|
||
rx = self.spi.xfer2([0x00, 0x00, 0x00, 0x00])
|
||
# 检查长度
|
||
if len(rx) < 4:
|
||
raise Exception("Short SPI read from device")
|
||
# 合并 3 个数据字节为 24 位整数（大端格式）
|
||
data = (rx[0] << 16) | (rx[1] << 8) | rx[2]
|
||
# 获取 CRC 字节
|
||
crc_received = rx[3] & 0xFF
|
||
# 计算并验证 CRC
|
||
crc_calculated = self._calculate_crc([rx[0], rx[1], rx[2]])
|
||
if crc_calculated != crc_received:
|
||
raise Exception(f"CRC mismatch: calculated 0x{crc_calculated:02x}, received 0x{crc_received:02x}, data: 0x{data:06x}")
|
||
val = data
|
||
else:
|
||
# 未启用 CRC，发送 3 个填充字节读取 24 位数据
|
||
rx = self.spi.xfer2([0x00, 0x00, 0x00])
|
||
if len(rx) < 3:
|
||
raise Exception("Short SPI read from device")
|
||
# 合并为 24 位整数（大端格式）
|
||
val = (rx[0] << 16) | (rx[1] << 8) | rx[2]
|
||
# 被注释掉的行：原来可能只取低 16 位
|
||
# val = (rx[0] << 16) | (rx[1] << 8) | 0x00
|
||
# 处理负数（符号扩展）
|
||
if val & 0x800000:
|
||
return val - (1 << 24)
|
||
return val
|
||
|
||
def convert_to_voltage(self, raw_value: int) -> float:
|
||
"""将 ADC 的原始数值转换为实际的电压值（单位：伏特）。
|
||
|
||
ADS124S08 是一个 24 位 ADC，可以测量双极性信号。
|
||
转换公式为：电压 = 原始值 × LSB
|
||
其中 LSB（Least Significant Bit，最低有效位）是 ADC 能分辨的最小电压变化。
|
||
|
||
LSB 的计算公式：
|
||
LSB = Vref / (Gain × 2^23)
|
||
推导过程：
|
||
- 24 位 ADC 的总量程是 2^24 = 16777216 个码值
|
||
- 因为是双极性（可测正负电压），有效量程是 -Vref/Gain 到 +Vref/Gain
|
||
- 双极性下，码值范围是 -2^23 到 2^23-1，共 2^24 个码值
|
||
- 所以 LSB = (Vref/Gain - (-Vref/Gain)) / 2^24 = 2×Vref/Gain / 2^24 = Vref / (Gain × 2^23)
|
||
|
||
举例：Vref=2.5V，Gain=1 时，LSB = 2.5 / 8388608 ≈ 0.298 微伏
|
||
|
||
参数:
|
||
raw_value: ADC 的原始 24 位有符号数值（由 cmd_read_data 或 drdy_read_data 返回）
|
||
|
||
返回:
|
||
转换后的电压值，单位伏特（V）
|
||
"""
|
||
# 读取 REF（参考电压配置）寄存器，获取当前参考电压的设置
|
||
ref_reg = self.read_reg(ADS124S08_REF)
|
||
# 从 REF 寄存器中提取 refsel（参考电压选择）字段（bit 3~2）
|
||
refsel = (ref_reg >> 2) & 0x03
|
||
# 检查参考电压选择：如果 refsel == 2，表示使用芯片内部参考电压
|
||
if refsel == 2:
|
||
# ADS124S08 的内部参考电压为 2.5V
|
||
vref = 2.5 # 使用内部参考电压 2.5V
|
||
else:
|
||
# 如果是外部参考电压，这里也假设为 2.5V（实际应根据外部电路确定）
|
||
vref = 2.5 # 假设外部参考电压也是 2.5V，实际项目中需要根据电路调整
|
||
|
||
# 读取 PGA（可编程增益放大器）寄存器，获取当前的增益设置
|
||
gain_factors = [1, 2, 4, 8, 16, 32, 64, 128]
|
||
pga_reg = self.read_reg(ADS124S08_PGA)
|
||
# 从 PGA 寄存器提取 PGA 使能位（bit 3）
|
||
pga_en = (pga_reg >> 3) & 0x01
|
||
if pga_en:
|
||
# 如果 PGA 已启用，从低 3 位（bit 2~0）读取增益编码，并查表得到实际增益值
|
||
gain = gain_factors[pga_reg & 0x07]
|
||
else:
|
||
# 如果 PGA 未启用，增益为 1 倍（信号直通，不放大）
|
||
gain = 1
|
||
|
||
# 计算 LSB（最低有效位对应的电压值）：
|
||
# LSB = Vref / (Gain × 2^23)
|
||
# - Vref：参考电压（伏特）
|
||
# - Gain：PGA 增益倍数
|
||
# - 2^23 = 8388608，对应 24 位有符号 ADC 的一半量程
|
||
lsb = vref / (gain * (1 << 23)) # 24 位双极性 ADC 的 LSB 计算
|
||
|
||
# 最终电压值 = ADC 原始数值 × LSB
|
||
return raw_value * lsb
|
||
|
||
def set_ref(self, en_monitor: int = 0, en_bufp: int = 0, en_bufn: int = 1, refsel: int = 0, refcon: int = 0) -> None:
|
||
"""配置 ADC 的参考电压（REF）寄存器。
|
||
|
||
参考电压决定了 ADC 的测量范围。例如参考电压为 2.5V 时，
|
||
双极性模式下可测量的范围是 -2.5V 到 +2.5V。
|
||
这个函数允许用户配置参考电压的监控、缓冲、来源和控制模式。
|
||
|
||
REF 寄存器的位定义（8 位）：
|
||
- bit 7~6 (en_monitor)：参考电压监控模式
|
||
- 0：禁用监控
|
||
- 1：仅 L0 使能
|
||
- 2：L0 + L1 使能
|
||
- 3：L0 + 电阻
|
||
- bit 5 (en_bufp)：正参考电压缓冲器（1=禁用缓冲器直通，0=使能缓冲器）
|
||
- bit 4 (en_bufn)：负参考电压缓冲器（1=禁用缓冲器直通，0=使能缓冲器）
|
||
- bit 3~2 (refsel)：参考电压源选择
|
||
- 0：P0+N0（外部引脚对）
|
||
- 1：P1+N1（外部引脚对）
|
||
- 2：内部参考电压（2.5V）
|
||
- bit 1~0 (refcon)：内部参考电压控制
|
||
- 0：内部参考关闭
|
||
- 1：内部参考开启（待机时可关闭以省电）
|
||
- 2：内部参考始终开启
|
||
|
||
参数:
|
||
en_monitor: 参考电压监控模式（0~3）
|
||
en_bufp: 正参考电压缓冲器控制（0=使能，1=禁用）
|
||
en_bufn: 负参考电压缓冲器控制（0=使能，1=禁用）
|
||
refsel: 参考电压源选择（0~2）
|
||
refcon: 内部参考电压控制（0~2）
|
||
"""
|
||
# 校验参数是否在有效范围内
|
||
if not (0 <= en_monitor <= 3):
|
||
raise ("en_monitor must be 0-3")
|
||
if not (0 <= en_bufp <= 1):
|
||
raise ("en_bufp must be 0 or 1")
|
||
if not (0 <= en_bufn <= 1):
|
||
raise ("en_bufn must be 0 or 1")
|
||
if not (0 <= refsel <= 2):
|
||
raise ("refsel must be 0-2")
|
||
if not (0 <= refcon <= 2):
|
||
raise ("refcon must be 0-2")
|
||
# 将各个参数拼接到 REF 寄存器的对应位上：
|
||
# REF 寄存器的位布局（8 位二进制数）：
|
||
# bit 7~6 = en_monitor，左移 6 位
|
||
# bit 5 = en_bufp， 左移 5 位
|
||
# bit 4 = en_bufn， 左移 4 位
|
||
# bit 3~2 = refsel， 左移 2 位
|
||
# bit 1~0 = refcon， 不移位
|
||
# 使用按位或（|）运算将各个字段组合成一个字节
|
||
ref_val = ((en_monitor & 0x03) << 6) | ((en_bufp & 0x01) << 5) | ((en_bufn & 0x01) << 4) | \
|
||
((refsel & 0x03) << 2) | (refcon & 0x03)
|
||
# 将组合好的值写入 REF 寄存器（地址 0x05）
|
||
self.write_reg(ADS124S08_REF, ref_val)
|
||
|
||
def check_ref(self) -> None:
|
||
"""读取并打印 REF（参考电压）寄存器的当前配置。
|
||
|
||
从 ADC 的 REF 寄存器读取当前值，解析出每个字段（监控模式、缓冲器设置、
|
||
参考电压选择、参考控制等），并以可读的文字形式打印到控制台。
|
||
方便调试时确认参考电压配置是否正确。
|
||
"""
|
||
# 读取 REF 寄存器（地址 0x05）的当前值
|
||
val = self.read_reg(ADS124S08_REF)
|
||
# 从寄存器值中提取 en_monitor 字段（bit 7~6）
|
||
en_monitor = (val >> 6) & 0x03
|
||
# 提取 en_bufp 字段（bit 5）
|
||
en_bufp = (val >> 5) & 0x01
|
||
# 提取 en_bufn 字段（bit 4）
|
||
en_bufn = (val >> 4) & 0x01
|
||
# 提取 refsel 字段（bit 3~2）
|
||
refsel = (val >> 2) & 0x03
|
||
# 提取 refcon 字段（bit 1~0）
|
||
refcon = val & 0x03
|
||
|
||
# 定义枚举值的文字描述，用于打印
|
||
monitor_names = ['已禁用', 'L0 使能', 'L0+L1 使能', 'L0+电阻']
|
||
refsel_names = ['P0+N0（外部引脚）', 'P1+N1（外部引脚）', '内部参考（2.5V）']
|
||
refcon_names = ['内部参考关闭', '内部参考开启', '始终开启']
|
||
|
||
# 打印参考电压监控模式（如果索引超出范围则显示 None）
|
||
print(f"参考电压监控: {monitor_names[en_monitor] if en_monitor < len(monitor_names) else None}")
|
||
# 打印正参考电压缓冲器状态：en_bufp=0 表示使能，=1 表示禁用
|
||
print(f"正参考电压缓冲器: {'已禁用' if en_bufp else '已使能'}")
|
||
# 打印负参考电压缓冲器状态
|
||
print(f"负参考电压缓冲器: {'已禁用' if en_bufn else '已使能'}")
|
||
# 打印参考电压源选择
|
||
print(f"参考电压源: {refsel_names[refsel] if refsel < len(refsel_names) else '未知'}")
|
||
# 打印内部参考电压控制模式
|
||
print(f"参考电压控制: {refcon_names[refcon] if refcon < len(refcon_names) else '未知'}")
|
||
|
||
def set_input_mux(self, pos_channel: int, neg_channel: int = ADS124S08_AINCOM) -> None:
|
||
"""配置输入多路复用器（INPUT MUX），选择要测量的模拟输入引脚。
|
||
|
||
ADS124S08 有 12 个模拟输入引脚（AIN0 ~ AIN11），通过输入多路复用器，
|
||
我们可以选择哪两个引脚连接到 ADC 内部进行测量。
|
||
|
||
两种模式：
|
||
- 单端测量：pos_channel = 要测量的引脚（如 AIN0），neg_channel = AINCOM（公共端）
|
||
此时测量的是该引脚相对于公共端的电压。
|
||
- 差分测量：pos_channel = 正输入端，neg_channel = 负输入端
|
||
此时测量的是两个引脚之间的电压差。
|
||
|
||
INPUT_MUX 寄存器布局（8 位）：
|
||
- bit 7~4：正输入通道号（pos_channel）
|
||
- bit 3~0：负输入通道号（neg_channel）
|
||
|
||
参数:
|
||
pos_channel: 正输入端通道号（AIN0~AIN11，或 AINCOM=0x0C）
|
||
neg_channel: 负输入端通道号，默认 AINCOM（适用于单端测量）
|
||
"""
|
||
# 将正输入通道号放在高 4 位（左移 4 位），负输入通道号放在低 4 位，
|
||
# 然后按位或（|）组合成一个字节
|
||
mux_val = ((pos_channel & 0x0F) << 4) | (neg_channel & 0x0F)
|
||
# 将组合后的值写入 INPUT_MUX 寄存器（地址 0x02）
|
||
self.write_reg(ADS124S08_INPUT_MUX, mux_val)
|
||
|
||
def check_input_mux(self) -> None:
|
||
"""读取并打印 INPUT_MUX（输入多路复用器）寄存器的当前配置。
|
||
|
||
用于调试时确认当前选择的是哪个输入通道。
|
||
"""
|
||
# 读取 INPUT_MUX 寄存器（地址 0x02）的当前值
|
||
val = self.read_reg(ADS124S08_INPUT_MUX)
|
||
# 高 4 位是正输入端通道号，低 4 位是负输入端通道号，以十六进制打印
|
||
print(f"正输入端: AIN{(val >> 4) & 0x0F}, 负输入端: AIN{val & 0x0F}")
|
||
|
||
def set_pga(self, pga_en: int = 0, gain: int = 0) -> None:
|
||
"""配置 PGA（可编程增益放大器）。
|
||
|
||
PGA 可以在 ADC 转换之前对模拟输入信号进行放大，这样即使是很微弱的信号
|
||
（如应变片输出的毫伏级电压）也能被 ADC 准确测量。
|
||
增益越大，可测量的信号幅度越小，但分辨率越高。
|
||
|
||
PGA 寄存器的位布局（8 位）：
|
||
- bit 3：PGA 使能位（1=使能，0=禁用）
|
||
- bit 2~0：增益选择码
|
||
|
||
增益编码对应表：
|
||
0: ×1 倍 1: ×2 倍 2: ×4 倍 3: ×8 倍
|
||
4: ×16 倍 5: ×32 倍 6: ×64 倍 7: ×128 倍
|
||
|
||
参数:
|
||
pga_en: PGA 使能（1=启用前置放大，0=禁用，信号直通）
|
||
gain: 增益编码（0~7），对应 ×1 到 ×128 倍放大
|
||
"""
|
||
# 校验参数是否在有效范围内
|
||
if not (0 <= pga_en <= 1):
|
||
raise ("pga_en must be 0 or 1")
|
||
if not (0 <= gain <= 7):
|
||
raise ("gain must be 0-7")
|
||
# 将 PGA 使能位放在 bit 3，增益编码放在 bit 2~0，组合成一个字节
|
||
pga_val = ((pga_en & 0x01) << 3) | (gain & 0x07)
|
||
# 将组合后的值写入 PGA 寄存器（地址 0x03）
|
||
self.write_reg(ADS124S08_PGA, pga_val)
|
||
|
||
def check_pga(self) -> None:
|
||
"""读取并打印 PGA（可编程增益放大器）寄存器的当前配置。
|
||
|
||
用于调试时确认当前的增益设置是否正确。
|
||
"""
|
||
# 读取 PGA 寄存器（地址 0x03）的当前值
|
||
val = self.read_reg(ADS124S08_PGA)
|
||
# 提取低 3 位作为增益编码
|
||
gain_val = val & 0x07
|
||
# 增益编码对应的实际放大倍数
|
||
gain_factors = [1, 2, 4, 8, 16, 32, 64, 128]
|
||
# 打印 PGA 使能状态和实际增益倍数
|
||
print(f"PGA 使能: {(val >> 3) & 0x01}, 增益: ×{gain_factors[gain_val]}")
|
||
|
||
def set_datarate(self, dr: int = 4, filter_type: int = 1,
|
||
mode: int = 0) -> None:
|
||
"""配置 DATA_RATE（数据速率）寄存器，设置 ADC 的采样速度和转换模式。
|
||
|
||
数据速率决定了 ADC 每秒进行多少次采样。速率越高，采样越快，
|
||
但噪声也越大（信噪比降低）。速率越低，采样越慢，但精度越高。
|
||
|
||
DATA_RATE 寄存器的位布局（8 位）：
|
||
- bit 7~6：保留位（未使用）
|
||
- bit 5：转换模式（0=连续转换，1=单次转换）
|
||
- bit 4：滤波器类型（0=Sinc3 滤波器，1=低延迟滤波器）
|
||
- bit 3~0：数据速率编码
|
||
|
||
数据速率编码对应表（编码 0~13）：
|
||
0: 2.5 SPS 1: 5 SPS 2: 10 SPS 3: 16.6 SPS
|
||
4: 20 SPS 5: 50 SPS 6: 60 SPS 7: 100 SPS
|
||
8: 200 SPS 9: 400 SPS 10: 800 SPS 11: 1000 SPS
|
||
12: 2000 SPS 13: 4000 SPS
|
||
|
||
参数:
|
||
dr: 数据速率编码（0~13）
|
||
filter_type: 滤波器类型（0=Sinc3，1=低延迟滤波器）
|
||
- Sinc3 滤波器：噪声低但转换速度慢，适合高精度测量
|
||
- 低延迟滤波器：响应快但噪声略高，适合需要快速读取的场景
|
||
mode: 转换模式（0=连续转换，1=单次转换）
|
||
- 连续模式：ADC 持续不断地进行转换，每次完成后自动开始下一次
|
||
- 单次模式：每次转换完成后停止，需要再次发送 START 命令才继续转换
|
||
"""
|
||
# 校验参数在有效范围内
|
||
if not (0 <= dr <= 13):
|
||
raise Exception("dr must be 0-13")
|
||
if not (0 <= filter_type <= 1):
|
||
raise Exception("filter_type must be 0-1")
|
||
if not (0 <= mode <= 1):
|
||
raise Exception("mode must be 0-1")
|
||
|
||
# 将 mode 放在 bit 5，filter_type 放在 bit 4，dr 编码放在 bit 3~0
|
||
dr_val = ((mode & 0x01) << 5) | ((filter_type & 0x01) << 4) | (dr & 0x0F)
|
||
# 将组合后的值写入 DATA_RATE 寄存器（地址 0x04）
|
||
self.write_reg(ADS124S08_DATA_RATE, dr_val)
|
||
|
||
def check_datarate(self) -> None:
|
||
"""读取并打印 DATA_RATE（数据速率）寄存器的当前配置。
|
||
|
||
用于调试时确认当前的数据速率、滤波器类型和转换模式。
|
||
"""
|
||
# 读取 DATA_RATE 寄存器（地址 0x04）的当前值
|
||
val = self.read_reg(ADS124S08_DATA_RATE)
|
||
# 提取低 4 位作为数据速率编码
|
||
dr = val & 0x0F
|
||
# 提取 bit 4 作为滤波器类型
|
||
filter_type = (val >> 4) & 0x01
|
||
# 提取 bit 5 作为转换模式
|
||
mode = (val >> 5) & 0x01
|
||
|
||
# 数据速率编码对应的实际每秒采样次数（SPS = Samples Per Second）
|
||
dr_values = [2.5, 5, 10, 16.6, 20, 50, 60, 100, 200, 400, 800, 1000, 2000, 4000]
|
||
# 滤波器类型名称
|
||
filter_names = ['Sinc3 滤波器', '低延迟滤波器']
|
||
# 转换模式名称
|
||
mode_names = ['连续转换', '单次转换']
|
||
|
||
# 打印数据速率（如果编码超出范围则显示 None）
|
||
print(f"数据速率: {dr_values[dr] if dr < len(dr_values) else None} SPS")
|
||
# 打印滤波器类型
|
||
print(f"滤波器类型: {filter_names[filter_type] if filter_type < len(filter_names) else None}")
|
||
# 打印转换模式
|
||
print(f"转换模式: {mode_names[mode] if mode < len(mode_names) else None}")
|
||
|
||
def check_status(self) -> None:
|
||
"""读取并打印 STATUS（状态）寄存器的当前值，检查 ADC 工作状态。
|
||
|
||
STATUS 寄存器的位含义：
|
||
- bit 7：上电复位标志（POR，Power-On Reset），1 表示芯片发生过上电复位
|
||
- bit 6：ADC 未就绪标志，1 表示 ADC 还没有准备好进行转换
|
||
- bit 5~0：其他状态标志位
|
||
|
||
通过检查这些标志可以判断 ADC 是否工作正常。
|
||
"""
|
||
# 读取 STATUS 寄存器（地址 0x01）的当前值
|
||
val = self.read_reg(ADS124S08_STATUS)
|
||
# 检查 bit 7：上电复位标志
|
||
if val & 0b10000000:
|
||
print("检测到上电复位（POR），需要清除该标志")
|
||
# 检查 bit 6：ADC 就绪标志
|
||
if val & 0b01000000:
|
||
print("ADC 尚未就绪，可能还在初始化中")
|
||
# 检查低 6 位的其他标志位
|
||
if val & 0b00111111:
|
||
print("ADC 状态标志:", bin(val & 0b00111111))
|
||
|
||
def clear_por(self) -> None:
|
||
"""清除 STATUS 寄存器的上电复位（POR）标志位。
|
||
|
||
在芯片上电复位后，STATUS 寄存器的 bit 7 会被设为 1，
|
||
表示发生过上电复位。向 STATUS 寄存器写入 0x00 可以将这个标志清零。
|
||
之后程序就可以通过检查这个标志来判断芯片是否意外掉电重启过。
|
||
"""
|
||
# 向 STATUS 寄存器（地址 0x01）写入 0x00，将所有标志清零
|
||
self.write_reg(ADS124S08_STATUS, 0x00)
|
||
|
||
def request_channels(self, channels: list[int]) -> list[int]:
|
||
"""按顺序逐个测量指定的多个单端通道，并返回测量结果。
|
||
|
||
此方法适用于单次转换模式（Single-shot mode），它会：
|
||
1. 检查 ADC 是否配置为单次转换模式
|
||
2. 对于列表中的每个通道，切换到该通道，启动一次转换，等待转换完成，读取数据
|
||
3. 收集所有通道的原始 ADC 值并返回
|
||
|
||
参数:
|
||
channels: 要测量的通道号列表，例如 [0, 1, 2] 表示测量 AIN0、AIN1、AIN2
|
||
每个通道对应单端测量（以 AINCOM 为公共端）
|
||
|
||
返回:
|
||
每个通道的原始 ADC 值列表（24 位有符号整数），顺序与输入 channels 相同
|
||
"""
|
||
# 读取 DATA_RATE 寄存器，检查当前是否配置为单次转换模式
|
||
val = self.read_reg(ADS124S08_DATA_RATE)
|
||
# 检查 DATA_RATE 寄存器的 bit 5：0=连续模式，1=单次模式
|
||
if val & 0b00100000:
|
||
# 如果是单次模式，直接通过（pass 语句什么都不做）
|
||
pass # 设备已处于单次转换模式
|
||
else:
|
||
# 如果是连续模式，抛出异常，因为此方法只适用于单次模式
|
||
raise Exception("设备未处于单次转换模式")
|
||
|
||
# 数据速率编码到实际 SPS 的映射表
|
||
dr_values = [2.5, 5, 10, 16.6, 20, 50, 60, 100, 200, 400, 800, 1000, 2000, 4000]
|
||
# 计算等待时间：1 秒 ÷ 每秒采样次数 + 额外 1 毫秒的余量
|
||
# 例如 20 SPS 时，每次转换需要 1/20 = 50ms，再加上 1ms 余量
|
||
wait_time = 1.0 / dr_values[val & 0x0F] + 0.001 # 增加一点余量，确保转换完成
|
||
# 创建一个空列表，用于存储每个通道的测量结果
|
||
values = []
|
||
# 遍历每个要测量的通道
|
||
for ch in channels:
|
||
# 将输入多路复用器切换到当前通道（单端模式，负端接 AINCOM）
|
||
self.set_input_mux(pos_channel=ch, neg_channel=ADS124S08_AINCOM)
|
||
# 如果配置了 DRDY 引脚并且成功创建了 Button 对象
|
||
if self.drdy_pin and self._drdy_pin is not None:
|
||
# 发送 START 命令，启动一次单次转换
|
||
self.write_cmd(ADS124S08_CMD_START)
|
||
# 被注释掉的代码：原来的实现可能用 wait_for_press() 等待 DRDY 引脚变低
|
||
# 但被替换为固定延时，因为 DRDY 引脚检测在某些情况下可能不稳定
|
||
# time.sleep(0.001)
|
||
# self._drdy_pin.wait_for_press()
|
||
# 等待足够长的时间让 ADC 完成转换
|
||
time.sleep(wait_time)
|
||
# 读取转换结果
|
||
val = self.cmd_read_data()
|
||
else:
|
||
# 如果没有配置 DRDY 引脚，直接发送 START 命令
|
||
self.write_cmd(ADS124S08_CMD_START)
|
||
# 等待转换完成
|
||
time.sleep(wait_time)
|
||
# 读取转换结果
|
||
val = self.cmd_read_data()
|
||
# 将当前通道的测量值添加到结果列表中
|
||
values.append(val)
|
||
# 返回所有通道的测量结果列表
|
||
return values |