Use of multiple HX711 modules

[FrankHenckens]

Hello,

I am using the HX711 gpio library of Robert-hh. I use multiple HX711 modules and only the last one I define triggers continuously. The rest triggers one time, afther that I get values but not the exact right ones. I was wondering how I can use multiple HX711 modules but without the pins overwriting each other.

All help is welcome!

[robert-hh]

Since the HX711 does not have something like a device addressing, pins cannot generally be shared. The CLK pin can be shared, since it is an input to the HX711. But the data pin must be separate per HX711. So you have to assign the HX711 DATA to several Pins of your board, or you have to use an external multiplexer. But since the multiplexer needs control pins as well, its only effective if you want to control four HX711 devices and more.

[FrankHenckens]

that would be wonderfull, I renewed the library with the gpio, and now I get 0 for all the raw values of the load cells.

[FrankHenckens]

the library I used before:

from machine import Pin, Timer
import time
import rp2

class HX711:
    def __init__(self, clock, data, gain=128):
        self.clock = clock
        self.data = data
        self.clock.value(False)

        self.GAIN = 0
        self.OFFSET = 0
        self.SCALE = 1

        self.time_constant = 0.25
        self.filtered = 0
        self.sm_timer = Timer()

        # create the state machine
        self.sm = rp2.StateMachine(0, self.hx711_pio, freq=1_000_000,
                                   sideset_base=self.clock, in_base=self.data,
                                   jmp_pin=self.data)
        self.set_gain(gain);


    @rp2.asm_pio(
        sideset_init=rp2.PIO.OUT_LOW,
        in_shiftdir=rp2.PIO.SHIFT_LEFT,
        autopull=False,
        autopush=False,
    )
    def hx711_pio():
        pull()              .side (0)   # get the number of clock cycles
        mov(x, osr)         .side (0)

        label("bitloop")
        nop()               .side (1)   # active edge
        nop()               .side (1)
        in_(pins, 1)        .side (0)   # get the pin and shift it in
        jmp(x_dec, "bitloop")  .side (0)   # test for more bits
        
        label("finish")
        push(block)         .side (0)   # no, deliver data and start over


    def set_gain(self, gain):
        if gain is 128:
            self.GAIN = 1
        elif gain is 64:
            self.GAIN = 3
        elif gain is 32:
            self.GAIN = 2

        self.read()
        self.filtered = self.read()

    def conversion_done_cb(self, data):
        self.conversion_done = True
        data.irq(handler=None)

    def read(self):
        self.conversion_done = False
        self.data.irq(trigger=Pin.IRQ_FALLING, handler=self.conversion_done_cb)
        # wait for the device being ready
        for _ in range(500):
            if self.conversion_done == True:
                break
            time.sleep_ms(1)
        else:
            self.data.irq(handler=None)
            raise OSError("Sensor does not respond")
        # Feed the waiting state machine & get the data
        self.sm.active(1)  # start the state machine
        self.sm.put(self.GAIN + 24 - 1)     # set pulse count 25-27, start
        result = self.sm.get() >> self.GAIN # get the result & discard GAIN bits
        self.sm.active(0)  # stop the state machine
        if result == 0x7fffffff:
            raise OSError("Sensor does not respond")

        # check sign
        if result > 0x7fffff:
            result -= 0x1000000

        return result

    def read_average(self, times=3):
        sum = 0
        for i in range(times):
            sum += self.read()
        return sum / times

    def read_lowpass(self):
        self.filtered += self.time_constant * (self.read() - self.filtered)
        return self.filtered

    def get_value(self):
        return self.read_lowpass() - self.OFFSET

    def get_units(self):
        return self.get_value() / self.SCALE

    def tare(self, times=15):
        self.set_offset(self.read_average(times))

    def set_scale(self, scale):
        self.SCALE = scale

    def set_offset(self, offset):
        self.OFFSET = offset

    def set_time_constant(self, time_constant = None):
        if time_constant is None:
            return self.time_constant
        elif 0 < time_constant < 1.0:
            self.time_constant = time_constant

    def power_down(self):
        self.clock.value(False)
        self.clock.value(True)

    def power_up(self):
        self.clock.value(False) 

The main code I am running:

from machine import I2C, Pin, UART
import utime
from hx711 import HX711
from lcd_api import LcdApi
from pico_i2c_lcd import I2cLcd

# Adres bekend maken & display afmetingen
I2C_ADDR     = 0x27
I2C_NUM_ROWS = 2
I2C_NUM_COLS = 16

# Pinnen van I2C backpack & welke bus + frequentie
i2c = I2C(0, sda=Pin(20), scl=Pin(21), freq=400000)
lcd = I2cLcd(i2c, I2C_ADDR, I2C_NUM_ROWS, I2C_NUM_COLS)

# Pinnen HX711 modules voor 4 loadcellen
hx1 = HX711(clock=Pin(5), data=Pin(4), gain=128)
hx2 = HX711(clock=Pin(7), data=Pin(6), gain=128)
hx3 = HX711(clock=Pin(9), data=Pin(8), gain=128)
hx4 = HX711(clock=Pin(11), data=Pin(10), gain=128)

# Tare uitvoeren en offset instellen voor elke loadcell
hx1.tare()
hx2.tare()
hx3.tare()
hx4.tare()

# Instellen van UART voor RFID-reader
uart = UART(0, baudrate=9600, tx=Pin(16), rx=Pin(17))

# Functie om commando's te versturen
def send_command(command):
    bcc = 0  
    for byte in command:
        bcc ^= byte    
    uart.write(command) 
    print(f"Command sent: {command}")

# Functie om antenne te selecteren
def select_antenna_1():
    command = bytearray([0x04, 0xF2, 0xA0, 0x01, 0x57])  
    send_command(command)

# Bevestiging van antenneselectie
def confirm_antenna_selection():
    print("Wachten op bevestiging van antenneselectie...")
    utime.sleep(1)  

    if uart.any():
        response = uart.read()  
        print(f"Response antenne ontvangen: {response}")
        return True

    else:
        print("Geen respons ontvangen na antenneselectie.")
        return False

# Functie om RFID-tag te lezen
def read_iso_tag():
    command = bytearray([0x03, 0xEA, 0x53, 0xBA])  
    send_command(command)
    utime.sleep(2)  
    if uart.any():
        response = uart.read()
        print(f"Tag data ontvangen (bytes): {[hex(byte) for byte in response]}") 
        
        if len(response) > 1:
            tag_id = int.from_bytes(response[1:5], 'big')  
            print(f"Tagnummer: {tag_id}")
            
            # Toon het tagnummer op de tweede regel van het LCD display
            lcd.move_to(0, 1)
            lcd.putstr(f"Tag: {tag_id}")
            
        else:
            print("Ongeldige tagdata ontvangen.")
    else:
        print("Geen tag gelezen.")

# Functie om gewicht te lezen en weer te geven        
def display_weight():
    try:
        # Lees de ruwe waarde uit per loadcell
        weight1 = hx1.read()
        weight2 = hx2.read()
        weight3 = hx3.read()
        weight4 = hx4.read()

        # Toon ruwe waarden loadcellen
        print(f"Ruwe waarden: HX1: {weight1}, HX2: {weight2}, HX3: {weight3}, HX4: {weight4}")

        # Kalibratiefactor aanpassen per loadcell
        scaled_weight1 = ((weight1 - 254085.6) / 7981)  
        scaled_weight2 = ((weight2 - 254131.9) / 7997)
        scaled_weight3 = ((weight3 - 254094.5) / 7996)
        scaled_weight4 = ((weight4 - 254115.8) / 7997)

        # Totaalgewicht door gewicht van loadcellen op te tellen
        total_weight = scaled_weight1 + scaled_weight2 + scaled_weight3 + scaled_weight4

        # Vermijd negatieve gewichten
        if total_weight < 0:
            total_weight = 0
        
        # Toon het totale gewicht op het display
        lcd.move_to(0, 0)
        lcd.putstr("                ")  # Leeg de eerste regel
        lcd.move_to(0, 0)
        lcd.putstr("Gewicht:")
        lcd.move_to(9, 0)
        lcd.putstr("{:.2f} Kg".format(total_weight))  # Gewicht met 2 decimalen tonen

    except OSError as e:
        lcd.clear()
        lcd.putstr("Error: HX711")
        print("Error:", e)

# OpstartDisplay
def greeting():
    lcd.clear()
    lcd.move_to(6, 0)
    lcd.putstr("H&F")
    lcd.move_to(2, 1)
    lcd.putstr("Electronics")
    utime.sleep(2)
    lcd.clear()
    utime.sleep(1)
    lcd.move_to(5, 0)
    lcd.putstr("Zeugen")
    lcd.move_to(2, 1)
    lcd.putstr("Weeg Systeem")
    utime.sleep(3)
    lcd.clear()
    utime.sleep(1)


# Doe de antenneselectie en bevestiging
print("Antenne 1 selecteren...")
select_antenna_1()
utime.sleep(3)

print("Bevestigen van antenneselectie...")
if confirm_antenna_selection():
    
    print("Antenne selectie bevestigd. Begin met het lezen van tags.")
    
    #Loop begint
    while True:
        print("Loop gestart")
        display_weight()
        read_iso_tag()
        utime.sleep(1)
        display_weight()
        utime.sleep(1)
        display_weight()
        utime.sleep(1)
        display_weight()
        utime.sleep(1)
        display_weight()
        utime.sleep(1)
        lcd.putstr("                ")  # Leeg de tweede regel
        utime.sleep(1)
else:
    print("Antenne selectie mislukt.") 

This code is also for reading RFID, but that part works.

[robert-hh]

So I found some time for a test with 2 HX711 boards. Script below. Using the file hx711_gpio.py I get reasonable results from both devices. Note that the Pin objects have to be initialized before. Using hx711_pio.py only talks to the second HX711. So that code seems to need a re-haul.

from hx711_gpio import HX711
from machine import Pin

hx1 = HX711(clock=Pin(5, Pin.OUT), data=Pin(4, Pin.IN), gain=128)
hx2 = HX711(clock=Pin(7, Pin.OUT), data=Pin(6, Pin.IN), gain=128)

def run():
    for _ in range(10):
        print(hx1.read(), hx2.read())

[robert-hh]

The hx711 repository is updated such the the hx711_pio.py code works with more than a single HX711. The state machine has to be selected in the constructor.

[FrankHenckens]

Thank you for all your help, the system works as I want now.

[bidrohini]

Each HX711 module should have its own dedicated GPIO pins for DATA and SCK. Sharing pins across modules will cause conflicts.
from hx711 import HX711

hx1 = HX711(dout_pin=17, pd_sck_pin=27) # HX711 instance 1
hx2 = HX711(dout_pin=22, pd_sck_pin=23) # HX711 instance 2
hx3 = HX711(dout_pin=5, pd_sck_pin=6) # HX711 instance 3

hx1.set_scale(1000)
hx1.tare()

hx2.set_scale(1000)
hx2.tare()

hx3.set_scale(1000)
hx3.tare()

value1 = hx1.read()
value2 = hx2.read()
value3 = hx3.read()

print(f"HX711 1: {value1}")
print(f"HX711 2: {value2}")
print(f"HX711 3: {value3}")

You can design a dual HX711 scales board
https://www.pcbway.com/project/shareproject/Dula_HX711_scales_board_17abe179.html