from hx711 import HX711

# Define the pins used for the HX711 module
DOUT_PIN = 27
PD_SCK_PIN = 14

# Create an instance of the HX711 class
hx711 = HX711(DOUT_PIN, PD_SCK_PIN)

# Set the calibration factor for your load cell
CAL_FACTOR = 1000

# Tare the load cell
hx711.tare()

# Read the weight continuously
while True:
    weight = hx711.read() / CAL_FACTOR
    print("Weight: {} g".format(weight))
    utime.sleep(1)

main.py

diagram.json

import machine
import utime

class HX711:
    def __init__(self, dout_pin, pd_sck_pin, gain=128, cal_factor=1):
        self._dout_pin = machine.Pin(dout_pin, machine.Pin.IN)
        self._pd_sck_pin = machine.Pin(pd_sck_pin, machine.Pin.OUT)
        self._gain = gain
        self._cal_factor = cal_factor

    def _set_gain(self):
        for i in range(self._gain):
            self._pd_sck_pin.on()
            utime.sleep_us(1)
            self._pd_sck_pin.off()
            utime.sleep_us(1)

    def _wait_for_ready(self):
        while self._dout_pin.value():
            pass

    def _read_data(self):
        data = bytearray(3)
        for i in range(3):
            for j in range(8):
                self._pd_sck_pin.on()
                data[i] |= (self._dout_pin.value() << (7 - j))
                self._pd_sck_pin.off()
        data[2] ^= 0x80
        return data

    def _read_raw(self):
        self._wait_for_ready()
        data = self._read_data()
        self._set_gain()
        return int.from_bytes(data, "big")  # remove the signed=True argument

    def read(self):
        return self._read_raw() / self._cal_factor

    def tare(self, num_samples=10):
        # Take a few samples and average them to get the tare value
        tare_sum = 0
        for i in range(num_samples):
            tare_sum += self._read_raw()
            utime.sleep_ms(10)
        self._cal_factor = tare_sum / num_samples

    def set_calibration_factor(self, cal_factor):
        self._cal_factor = cal_factor