HX711模块驱动for K210

这是k210开发板上用micropython驱动hx711称重模块的程序，很久之前写的，实际上非常简单。包含了读取原始数据和简单的滑动窗口滤波，主要是对数据进行滑动窗口排序，去除最大和最小的1/4，然后均值滤波。

scale_factor是原始数据和实际重量的比例因子

from Maix import GPIO
from fpioa_manager import fm
import time

class HX711:
    def __init__(self, hx711_sck, hx711_dt, filter_size=12, scale_factor=210.88):
        fm.register(hx711_sck, fm.fpioa.GPIOHS3)
        fm.register(hx711_dt, fm.fpioa.GPIOHS6)
        self.sck = GPIO(GPIO.GPIOHS3, GPIO.OUT)
        self.dt = GPIO(GPIO.GPIOHS6, GPIO.IN, GPIO.PULL_UP)
        self.offset = 0  # 偏移量初始化为0
        self.filter_size = filter_size  # 滤波器大小
        self.filter_buffer = [0] * filter_size  # 初始化滤波器缓冲区为0
        self.scale_factor = scale_factor  # 缩放因子
        self.last_filtered = 0 #初始值置0
        self.tare()  # 执行去皮操作
    def reset(self):
        self.sck.value(1)
        time.sleep_ms(100)
        self.sck.value(0)
        time.sleep_ms(100)
    def get_raw(self, gain=128):
        count = 0
        while self.dt.value() == 1:
            pass
        for i in range(24):  # 读取24位数据
            self.sck.value(1)
            time.sleep_us(1)
            self.sck.value(0)
            time.sleep_us(1)
            count = count << 1
            if self.dt.value() == 1:
                count += 1
        # 根据增益设置最后一个时钟脉冲
        if gain == 128:
            pulse_count = 1
        for _ in range(pulse_count):
            self.sck.value(1)
            time.sleep_us(1)
            self.sck.value(0)
            time.sleep_us(1)
        count = count ^ 0x800000  # 转换为有符号整数
        return count
    def quick_sort(self, arr):
        if len(arr) <= 1:
            return arr
        pivot = arr[len(arr) // 2]
        left = [x for x in arr if x < pivot]
        middle = [x for x in arr if x == pivot]
        right = [x for x in arr if x > pivot]
        return self.quick_sort(left) + middle + self.quick_sort(right)
    def tare(self):
        raw_data = [self.get_raw() for _ in range(8)]
        sorted_data = self.quick_sort(raw_data)
        trimmed_data = sorted_data[2:-2]
        self.offset = sum(trimmed_data) / len(trimmed_data)

    def filter_0(self, data):
        self.filter_buffer = self.filter_buffer[1:] + [data]  # 将数据添加到滤波器缓冲区
        filtered_data = self.quick_sort(self.filter_buffer)  # 对缓冲区进行排序
        trimmed_data = filtered_data[self.filter_size//4 : -self.filter_size//4]  # 去除最大和最小的一部分
        return sum(trimmed_data) / len(trimmed_data)  # 返回剩余数据的平均值

    def read(self):
        raw_data = self.get_raw()-self.offset
        mean_filtered = self.filter_0(raw_data)  # 然后进行滤波
        weight_data = mean_filtered/self.scale_factor
        rounded_data = round(weight_data, 0)  # 对滤波后的数据进行四舍五入，保留至少1位小数
        if -1 < rounded_data < 0.9:
            return 0
        return rounded_data
if __name__ == "__main__":
    hx711 = HX711(20,19)
    while True:
        print(hx711.read())