Mesurer un poids raspberry PI et hx711


3 posts
by Seregone » Fri May 12, 2017 3:08 pm
Bonjour, je poste aujourd'hui car j'ai un probléme pour mesurer un poids via mon raspberry PI:

Voici tout d'abord le matériel que j'utilise :
Le raspberry pi 3
Une load cell 3kg
Une puce hx711

J'ai fais les branchements comme il se doit je suppose, puisque j'ai suivis plusieurs tutos :
Fil rouge : E+
Fil noir :E-
Fil blanc : A+
Fil vert : A-

J'ai ensuite connecté l'autre côté de la puce comme suit:
GND : PIN 25 (GROUND)
DT : PIN 29 (BCM GPIO5)
SCK : PIN 31 (BCM GPIO6)
VCC: PIN 2 (5V)

Voici pour les branchements:
Au niveau du script, j'ai utilisé celui-ci qui est identique a celui-ci en changeant les pin:
https://github.com/tatobari/hx711py

Code: Select all
import RPi.GPIO as GPIO
import time
import sys
import numpy  # sudo apt-get python-numpy

class HX711:
    def __init__(self, dout, pd_sck, gain=128):
        self.PD_SCK = pd_sck
        self.DOUT = dout

        GPIO.setmode(GPIO.BCM)
        GPIO.setup(self.PD_SCK, GPIO.OUT)
        GPIO.setup(self.DOUT, GPIO.IN)

        self.GAIN = 0
        self.REFERENCE_UNIT = 1  # The value returned by the hx711 that corresponds to your reference unit AFTER dividing by the SCALE.
       
        self.OFFSET = 1
        self.lastVal = long(0)

        self.LSByte = [2, -1, -1]
        self.MSByte = [0, 3, 1]
       
        self.MSBit = [0, 8, 1]
        self.LSBit = [7, -1, -1]

        self.byte_range_values = self.LSByte
        self.bit_range_values = self.MSBit

        self.set_gain(gain)

        time.sleep(1)

    def is_ready(self):
        return GPIO.input(self.DOUT) == 0

    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

        GPIO.output(self.PD_SCK, False)
        self.read()
   
    def createBoolList(self, size=8):
        ret = []
        for i in range(8):
            ret.append(False)
        return ret

    def read(self):
        while not self.is_ready():
            #print("WAITING")
            pass

        dataBits = [self.createBoolList(), self.createBoolList(), self.createBoolList()]
        dataBytes = [0x0] * 4

        for j in range(self.byte_range_values[0], self.byte_range_values[1], self.byte_range_values[2]):
            for i in range(self.bit_range_values[0], self.bit_range_values[1], self.bit_range_values[2]):
                GPIO.output(self.PD_SCK, True)
                dataBits[j][i] = GPIO.input(self.DOUT)
                GPIO.output(self.PD_SCK, False)
            dataBytes[j] = numpy.packbits(numpy.uint8(dataBits[j]))

        #set channel and gain factor for next reading
        for i in range(self.GAIN):
            GPIO.output(self.PD_SCK, True)
            GPIO.output(self.PD_SCK, False)

        #check for all 1
        #if all(item is True for item in dataBits[0]):
        #    return long(self.lastVal)

        dataBytes[2] ^= 0x80

        return dataBytes

    def get_binary_string(self):
        binary_format = "{0:b}"
        np_arr8 = self.read_np_arr8()
        binary_string = ""
        for i in range(4):
            # binary_segment = binary_format.format(np_arr8[i])
            binary_segment = format(np_arr8[i], '#010b')
            binary_string += binary_segment + " "
        return binary_string

    def get_np_arr8_string(self):
        np_arr8 = self.read_np_arr8()
        np_arr8_string = "[";
        comma = ", "
        for i in range(4):
            if i is 3:
                comma = ""
            np_arr8_string += str(np_arr8[i]) + comma
        np_arr8_string += "]";
       
        return np_arr8_string

    def read_np_arr8(self):
        dataBytes = self.read()
        np_arr8 = numpy.uint8(dataBytes)

        return np_arr8

    def read_long(self):
        np_arr8 = self.read_np_arr8()
        np_arr32 = np_arr8.view('uint32')
        self.lastVal = np_arr32

        return long(self.lastVal)

    def read_average(self, times=3):
        values = long(0)
        for i in range(times):
            values += self.read_long()

        return values / times

    def get_value(self, times=3):
        return self.read_average(times) - self.OFFSET

    def get_weight(self, times=3):
        value = self.get_value(times)
        value = value / self.REFERENCE_UNIT
        return value

    def tare(self, times=15):
       
        # Backup REFERENCE_UNIT value
        reference_unit = self.REFERENCE_UNIT
        self.set_reference_unit(1)

        value = self.read_average(times)
        self.set_offset(value)

        self.set_reference_unit(reference_unit)

    def set_reading_format(self, byte_format="LSB", bit_format="MSB"):
        if byte_format == "LSB":
            self.byte_range_values = self.LSByte
        elif byte_format == "MSB":
            self.byte_range_values = self.MSByte

        if bit_format == "LSB":
            self.bit_range_values = self.LSBit
        elif bit_format == "MSB":
            self.bit_range_values = self.MSBit

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

    def set_reference_unit(self, reference_unit):
        self.REFERENCE_UNIT = reference_unit

    # HX711 datasheet states that setting the PDA_CLOCK pin on high for a more than 60 microseconds would power off the chip.
    # I used 100 microseconds, just in case.
    # I've found it is good practice to reset the hx711 if it wasn't used for more than a few seconds.
    def power_down(self):
        GPIO.output(self.PD_SCK, False)
        GPIO.output(self.PD_SCK, True)
        time.sleep(0.0001)

    def power_up(self):
        GPIO.output(self.PD_SCK, False)
        time.sleep(0.0001)

    def reset(self):
        self.power_down()
        self.power_up()


Code: Select all
import sys
import time

import RPi.GPIO as GPIO
from weight import HX711

# choose pins on rpi (BCM5 and BCM6)
hx = HX711(5,6)

# HOW TO CALCULATE THE REFFERENCE UNIT
#########################################
# To set the reference unit to 1.
# Call get_weight before and after putting 1000g weight on your sensor.
# Divide difference with grams (1000g) and use it as refference unit.

hx.setReferenceUnit(21)

hx.reset()
hx.tare()

while True:

    try:
        val = hx.getWeight()
        print("{0: 4.4f}".format(val))

    except (KeyboardInterrupt, SystemExit):
        GPIO.cleanup()
        sys.exit()


Seulement voila, lorsque je lance le script, alors que je n'ai rien mis sur le capteur, j'ai des résultats trés étrange :

-8.2571
3.6000
-2.4952
-34.5429
-53.3524
-17.4476
14.8381
16.0762
17.7429
-13.6857
15.7429
27.2667
34.5048
-4.9238
-45.9714
-22.2095
2.0762
-15.7333
-32.5429
0.3619
-2.8762
14.9333
10.9333
-15.7333
-17.3048
-23.0667
-21.3524
-10.4476

Pourriez vous m'aider pour comprendre ce que j'ai mal fais !

Merci beaucoup, bonne journée.
Posts: 30
Joined: Tue Apr 04, 2017 2:54 pm
by jelopo » Sat May 13, 2017 6:34 am
Bonjour,

sans connaître ton matériel, j'ai trouvé cette info sur le forum UK https://www.raspberrypi.org/forums/view ... 1&t=144153

"If you have connected it to a weighing machine the normal calibration would be to take 50 or so readings "

A+
Posts: 1070
Joined: Wed Oct 17, 2012 7:53 pm
by Seregone » Sat May 13, 2017 12:56 pm
Niveau capteur j'ai celui ci : https://www.amazon.fr/%C3%A9lectronique ... teur+poids

Justement je ne comprend pas le calibrage, concrétement, est ce que normale que lorsque je lance la détection de poids la premiére fois, avec rien sur le capteur, j'ai des valeurs aléatoires comme cela ?
Posts: 30
Joined: Tue Apr 04, 2017 2:54 pm