from machine import Pin
from hx711 import HX711
from time import sleep
from picozero import Speaker


LoadCell_SCK_pin = 8
LoadCell_DOUT_pin = 9
LoadCellDout = Pin(LoadCell_DOUT_pin, Pin.IN, pull=Pin.PULL_DOWN) 
LoadCellSck = Pin(LoadCell_SCK_pin, Pin.OUT)
LoadCell = HX711(LoadCellSck, LoadCellDout)

led_red = Pin(10,Pin.OUT)
led_orange = Pin(11,Pin.OUT)
led_green = Pin(12,Pin.OUT)
buzzer = Speaker(5)
LoadCell.read_avg()

'''
LoadCellOffset = LoadCell.read_avg()
print("Add weight ")
sleep(5)

while LoadCell.read()-LoadCellOffset<2000: #. The system waits for the load cell to detect a significant change (more than 2000 units from the offset) to ensure the weight is placed correctly.
    print(LoadCell.read()-LoadCellOffset)
    pass

print("Add weight 123")
sleep(5)
print("Starts")
sleep(5)
referenceLoad = LoadCell.read_avg()
LoadCellScaling = referenceLoad- LoadCellOffset

print(int(LoadCellScaling),int(LoadCellOffset))
'''
LoadCellScaling = 2058
LoadCellOffset =  0

buzzer_count =0
while True:
    print("------ Add weight Main weight ----")
    sleep(5)
    print("Org Starts .. ....")
    sleep(5)
    TBW = ((LoadCell.read() - LoadCellOffset)/LoadCellScaling)*4.9
    print(TBW)
    if TBW>-1 and TBW<0:
        TBW =0
    TBW = round(TBW, 2)

    if TBW > 2.5 and TBW < 4.7:
        led_orange.value(1)
        led_red.value(0)
        led_green.value(0)
        buzzer_count =0

    elif TBW > 4.7:
        led_red.value(1)
        led_orange.value(0)
        led_green.value(0)
        if buzzer_count == 0:
            for i in range(5):
                buzzer.on()
                sleep(1)
                buzzer.off()
                sleep(1)
        buzzer_count = 1
    else:
        led_green.value(1)
        led_orange.value(0)
        led_red.value(0)
        buzzer_count =0

    print("Weight :",TBW,"Kg")

main.py

diagram.json

from utime import sleep_us, time, sleep
from machine import enable_irq, disable_irq, idle, Pin
from micropython import const
import time

class HX711:
    
    #DATA_BITS = const(24)
    
    def __init__(self, pd_sck, dout, gain=128):
        self.pSCK = pd_sck
        self.pOUT = dout
        #self.pSCK.value(False)

        self.GAIN = 0
        self.offset = 0
        
        self.set_gain(gain)
    
    def set_gain(self,gain):
        if gain is 128:
            self.GAIN=1
        if gain is 64:
            self.GAIN=3
        if gain is 32:
            self.GAIN=2
            
    def ready(self):
        return self.pOUT.value()==0
    
    #This function can also be used for waiting in device
    def wait(self):
        t=time()
        while not self.ready():
            if (time()-t>const(5)):
                print("Device is not yet ready")
                sleep(0.6)
                
    def read(self):

        # wait for the device being ready
        for _ in range(500):
            if self.pOUT() == 0:
                break
            time.sleep_ms(1)
        else:
            raise OSError("Sensor does not respond")

        # shifting in data, gain & channel info
        res = 0
        for j in range(24 + self.GAIN):
            state = disable_irq()
            self.pSCK(True)
            self.pSCK(False)
            enable_irq(state)
            res = (res << 1) | self.pOUT()

        # shifting back the extra bits
        res >>= self.GAIN

        # converting from 2s complement to integer
        if res > 0x7fffff:
            res -= 0x1000000

        return res
    
    def tare(self):
        self.offset = self.read()
                
    
    def read_avg(self, times=100):
        sum=0
        for i in range(times):
            sum+=self.read()
        
        return sum/times
    
    
    def pow_down(self):
        self.pSCK.value(False)
        self.pSCK.value(True)
        
    def pow_up(self):
        self.pSCK.value(False)