HS-S46P 称重传感器

1、介绍

Hx711称重传感器是一种将力学量（如重量、压力）转换为电信号输出的装置，最常见类型，利用弹性体受力变形，粘贴其上的电阻应变片随形变改变电阻值，通过惠斯通电桥将电阻变化转化为电压信号，再经放大、模数转换输出数字信号。

2、原理图

3、模块参数

引脚名称	描述
G	GND（电源输入负极）
V	VCC（电源输入正极）
D	数据引脚
S	时钟引脚

供电电压： 3.3V-5V
连接方式：PH2.0 4P端子线
安装方式：螺丝固定

4、电路板尺寸

5、Arduino IDE示例程序

注意：程序上传时如果提示库文件报错，请先导入库文件！
Arduino IDE 库文件下载及导入教程：点击查看

示例程序（UNO开发板）：

#include <Hx711.h>

Hx711 scale6_5(6,5);

void setup(){
  scale6_5.setOffset(scale6_5.getAverageValue(30));
  scale6_5.setScale(363.47);
  Serial.begin(9600);
}

void loop(){
  Serial.println(scale6_5.getWeight(10));

}

6、ESP32 Python 示例（适用于Mixly IDE /米思齐）

开发板选择 Python ESP32 【ESP32 Generic(4MB)】切换为代码模式上传

注意：程序上传时如果提示库文件报错，请先导入库文件！
米思齐（Mixly）IDE ESP32库文件下载及导入教程：点击查看

示例程序（ESP32-Python）：

from machine import Pin
from utime import sleep_us, sleep_ms, time
import ujson
from micropython import const

class HX711Exception(Exception):
    pass

class InvalidMode(HX711Exception):
    pass

class DeviceIsNotReady(HX711Exception):
    pass

class HX711:
    CHANNEL_A_128 = const(1)
    CHANNEL_A_64 = const(3)
    CHANNEL_B_32 = const(2)

    DATA_BITS = const(24)
    MAX_VALUE = const(0x7fffff)
    MIN_VALUE = const(0x800000)
    READY_TIMEOUT_SEC = const(5)
    SLEEP_DELAY_USEC = const(80)

    def __init__(self, d_out: int, pd_sck: int, channel: int = CHANNEL_A_128, config_file="hx711setting.json"):
        self.d_out_pin = Pin(d_out, Pin.IN)
        self.pd_sck_pin = Pin(pd_sck, Pin.OUT, value=0)
        self._channel = channel
        self.offset = 0
        self.scale = 1.0
        self.config_file = config_file
        self.load_offset_scale()

    def _convert_from_twos_complement(self, value: int) -> int:
        if value & (1 << (self.DATA_BITS - 1)):
            value -= 1 << self.DATA_BITS
        return value

    def _set_channel(self):
        for i in range(self._channel):
            self.pd_sck_pin.value(1)
            self.pd_sck_pin.value(0)

    def _wait(self):
        t0 = time()
        while not self.is_ready():
            if time() - t0 > self.READY_TIMEOUT_SEC:
                raise DeviceIsNotReady()

    @property
    def channel(self) -> tuple:
        if self._channel == self.CHANNEL_A_128:
            return 'A', 128
        if self._channel == self.CHANNEL_A_64:
            return 'A', 64
        if self._channel == self.CHANNEL_B_32:
            return 'B', 32

    @channel.setter
    def channel(self, value):
        if value not in (self.CHANNEL_A_128, self.CHANNEL_A_64, self.CHANNEL_B_32):
            raise InvalidMode('Gain should be one of HX711.CHANNEL_A_128, HX711.CHANNEL_A_64, HX711.CHANNEL_B_32')
        self._channel = value
        if not self.is_ready():
            self._wait()
        for i in range(self.DATA_BITS):
            self.pd_sck_pin.value(1)
            self.pd_sck_pin.value(0)
        self._set_channel()

    def is_ready(self) -> bool:
        return self.d_out_pin.value() == 0

    def power_off(self):
        self.pd_sck_pin.value(0)
        self.pd_sck_pin.value(1)
        sleep_us(self.SLEEP_DELAY_USEC)

    def power_on(self):
        self.pd_sck_pin.value(0)
        self.channel = self._channel

    def read_raw(self):
        if not self.is_ready():
            self._wait()
        raw_data = 0
        for i in range(self.DATA_BITS):
            self.pd_sck_pin.value(1)
            self.pd_sck_pin.value(0)
            raw_data = (raw_data << 1) | self.d_out_pin.value()
        self._set_channel()
        return self._convert_from_twos_complement(raw_data)

    def tare(self, samples=50):
        total = sum(self.read_raw() for _ in range(samples))
        self.offset = total / samples
        return self.offset

    def set_scale(self, known_weight, samples=50):
        raw_total = sum(self.read_raw() for _ in range(samples))
        raw_avg = raw_total / samples
        self.scale = (raw_avg - self.offset) / known_weight
        if self.scale == 0:
            self.scale = 1
        return self.scale

    def get_weight(self, samples=25, filter_type="mean"):
        values = [self.read_raw() for _ in range(samples)]
        if filter_type == "median":
            values.sort()
            raw = values[len(values)//2]
        else:
            raw = sum(values)/len(values)
        return (raw - self.offset)/self.scale

    def save_offset_scale(self):
        with open(self.config_file, "w") as f:
            ujson.dump({'offset': self.offset, 'scale': self.scale}, f)

    def load_offset_scale(self):
        try:
            with open(self.config_file, "r") as f:
                data = ujson.load(f)
                self.offset = data.get("offset", 0)
                self.scale = data.get("scale", 1.0)
        except:
            self.offset = 0
            self.scale = 1.0
hx = HX711(d_out=17, pd_sck=16)


print("=== HX711 自动校准程序 ===")
print("1. 请确保秤上没有物体...")
sleep_ms(3000)
hx.tare()
print("去皮完成，offset =", hx.offset)

known_weight = 199
print("2. 请放入 %.2f g 重量的物品..." % known_weight)
sleep_ms(5000)
scale = hx.set_scale(known_weight)
print("校准完成，scale =", scale)

hx.save_offset_scale()
print("参数已保存，可以直接开始测量。")




while True:
    print(hx.get_weight(samples=50, filter_type="mean"))