def setup():
global hx, logger
logger = logging.getLogger(__name__)
if logLevel == "debug":
logger.setLevel(logging.DEBUG)
elif logLevel == "info":
logger.setLevel(logging.INFO)
elif logLevel == "error":
logger.setLevel(logging.ERROR)
else:
logger.setLevel(logging.INFO)
streamHandler = logging.StreamHandler()
rollingFileHandler = RotatingFileHandler(logFilePath,
maxBytes=10000,
backupCount=4)
formatter = logging.Formatter(loggingFormat)
streamHandler.setFormatter(formatter)
rollingFileHandler.setFormatter(formatter)
logger.addHandler(streamHandler)
logger.addHandler(rollingFileHandler)
hx = HX711(5, 6)
# I've found out that, for some reason, the order of the bytes is not always the same between versions of python, numpy and the hx711 itself.
# Still need to figure out why does it change.
# If you're experiencing super random values, change these values to MSB or LSB until to get more stable values.
# There is some code below to debug and log the order of the bits and the bytes.
# The first parameter is the order in which the bytes are used to build the "long" value.
# The second paramter is the order of the bits inside each byte.
# According to the HX711 Datasheet, the second parameter is MSB so you shouldn't need to modify it.
hx.set_reading_format("LSB", "MSB")
# HOW TO CALCULATE THE REFFERENCE UNIT
# To set the reference unit to 1. Put 1kg on your sensor or anything you have and know exactly how much it weights.
# In this case, 92 is 1 gram because, with 1 as a reference unit I got numbers near 0 without any weight
# and I got numbers around 184000 when I added 2kg. So, according to the rule of thirds:
# If 2000 grams is 184000 then 1000 grams is 184000 / 2000 = 92.
#hx.set_reference_unit(113)
hx.set_reference_unit(5091.04)
hx.reset()
hx.tare()
logger.info("Load sensor set up done")
def celda2():
hx = HX711(5, 6) # sck, dout
hx.set_reading_format("MSB", "MSB")
hx.set_reference_unit(-131)
hx.reset()
hx.tare()
print "Tare done! Add weight now..."
while True:
try:
val = hx.get_weight(5)
print("celda2 : {}".format(val))
hx.power_down()
hx.power_up()
time.sleep(0.000001)
except (KeyboardInterrupt, SystemExit):
cleanAndExit()
def __init__(self, dout=5, pd_sck=6):
super().__init__('scale_node')
self.declare_parameter('reference_unit', 386.619)
self._reference_unit = self.get_parameter('reference_unit').value
self.declare_parameter('update_interval_s', 0.1)
self._update_interval_s = self.get_parameter('update_interval_s').value
self._hx = HX711(dout, pd_sck)
self._hx.set_reading_format("MSB", "MSB")
self._hx.set_reference_unit(self._reference_unit)
self._subs = []
self._subs.append(
self.create_subscription(Bool, 'scale/enable',
self._enable_callback, 1))
self._value_pub = self.create_publisher(Float32, 'scale/value', 10)
self._timer = self.create_timer(self._update_interval_s,
self._timer_callback)
self._timer.cancel()
def get_weight(channel, offset, unit):
val = []
hx = HX711(channel[0], channel[1])
hx.set_reading_format('LSB', 'MSB')
hx.set_reference_unit(unit)
hx.reset()
hx.set_offset(offset)
while True:
try:
for i in range(3):
val.append(hx.get_weight(1))
del val[val.index(max(val))]
del val[val.index(min(val))]
result[Channels.index(channel)] = float('%.1f' % val[0])
val = []
hx.power_down()
hx.power_up()
time.sleep(0.2)
except (KeyboardInterrupt, SystemExit):
cleanAndExit(Channels.index(channel))
return result[:]
def test_06_gain_validation(self):
test_mapping = {
"wrong_gain_raises_error": (256),
"string_raises_error": ("128")
}
hx711 = HX711(dout_pin=5, pd_sck_pin=6, channel="A", gain=128)
for name, gain in test_mapping.items():
with self.subTest(name):
with self.assertRaises(ParameterValidationError):
hx711.channel_a_gain = gain
for value in hx711._valid_gains_for_channel_A:
with self.subTest(
"valid gain {value} should not raise".format(value=value)):
try:
hx711.channel_a_gain = value
except Exception as exception:
self.fail(
"{exception} was raised".format(exception=exception))
def loadread():
hx = HX711(29, 31)
hx.set_reading_format("MSB", "MSB")
#hx.set_reference_unit(92)
hx.reset()
hx.tare()
print("Tare done! Add weight now...")
try:
val = hx.get_weight(5)
print(val)
hx.power_down()
hx.power_up()
time.sleep(0.1)
except (KeyboardInterrupt, SystemExit):
cleanAndExit()
return val
def __init__(self, filename):
bakery = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
self.data_directory = '%s/web/thrust-tests' % bakery
self.prep_file(filename)
GPIO.setmode(GPIO.BCM)
GPIO.setup(LED_PIN, GPIO.OUT)
GPIO.setup(RELAY_PIN, GPIO.OUT)
GPIO.output(LED_PIN, False)
GPIO.output(RELAY_PIN, False)
self.ignite_start = -1
self.ignite_duration = 2.
self.hx = HX711(DATA_PIN, CLOCK_PIN)
self.hx.set_reading_format("LSB", "MSB")
self.hx.set_reference_unit(92)
self.hx.reset()
self.hx.tare(100)
self.start_time = time.time()
self.times = []
self.triggered = False
self.thrusts = []
GPIO.output(LED_PIN, True)
def __init__(self, gpio1=[18, 23, 24, 25], gpioLoad=[27, 17]):
self.spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI)
self.cs = digitalio.DigitalInOut(board.D5)
self.mcp = MCP.MCP3008(self.spi, self.cs)
self.channel = AnalogIn(self.mcp, MCP.P0)
# specify the motor type, the library may need to be changed if the motor is replaced
self.mymotortest = RpiMotorLib.BYJMotor("MyMotorOne", "28BYJ")
self.gpio1 = gpio1
# use pin27 and 17 to connect the driver board
self.hx = HX711(27, 17)
self.hx.reset()
self.hx.zero()
self.speed = 0
self.completions = 0
self.flag = False
print("Tare done! Add weight now...")
self.distance = Value('i', 0)
self.cmd = Value('i', 0)
def main():
# Initialize parameters at t = 0
num_people = 4 # Initialize number of people
weight_array = np.zeros(num_people) # Store weights in an array
global weight_before
weight_before = measure_sink() # Initial weight in sink
#faces = load_faces(num_people) # Stores template faces for each person
names = ["Brooke", "Eric", "Francis",
"Nithin"] # Stores names of each person
# Initialize load cell
hx = HX711(5, 6)
hx.set_reading_format("LSB", "MSB")
hx.set_reference_unit(92) # Calibrate reference unit to 1g
hx.reset()
hx.tare()
# Initialize Display
window = tk.Tk()
window.title("Dirty dishes")
window.configure(background="black")
myFont = tkinter.font.Font(family='Helvetica', size=25, weight="bold")
# Initialize Face Recognition
recognizer = cv2.face.LBPHFaceRecognizer_create()
recognizer.read('trainer/trainer.yml')
cascadePath = "haarcascade_frontalface_default.xml"
faceCascade = cv2.CascadeClassifier(cascadePath)
font = cv2.FONT_HERSHEY_SIMPLEX
cam = cv2.VideoCapture(1)
# Iterate for t > 0
update_display() # calls update_data as well
window.mainloop()
# Stop the camera
cam.release()
# Close all windows
cv2.destroyAllWindows()
def __init__(self, port, logfname, nscale):
"""
"""
if not port:
logging.warning(
'## hxboard __init__ requires a clock/data port (as [5,6] eg) please'
)
return
self.logdat = False
self.recording = False
self.outfile = None
self.nscale = nscale
self.lastval = 0.0
self.configfile = 'scale%d.config' % nscale
self.scale = 1.0
self.offset = 0
self.port = port
self.lasttime = datetime.datetime.now()
if os.path.isfile(self.configfile):
s = open(self.configfile, 'r').read()
sc, offs = s.split(',')
self.scale = float(sc)
self.offset = int(offs)
self.calibrated = True
else:
self.calibrated = False
hxnew = HX711(self.port[0], self.port[1])
hxnew.set_reading_format("MSB", "MSB")
hxnew.set_reference_unit(self.scale)
hxnew.set_offset(self.offset)
self.hx = hxnew
scale_ready = self.do_Ready()
if not scale_ready:
# timeout
logging.warning(
"!!! Scale ready timeout - is scale %d @ port %s connected? Not calibrating"
% (self.nscale, self.port))
else:
if not self.calibrated:
self.do_Calibrate()
def balanca():
hx = HX711(5, 6)
hx.set_reading_format("LSB", "MSB")
hx.set_reference_unit(92) #calibragem
hx.reset()
hx.tare()
while True:
try:
val = hx.get_weight(5)
print val
hx.power_down()
hx.power_up()
time.sleep(0.5)
except (KeyboardInterrupt, SystemExit):
cleanAndExit()
return val
def grindSpice(motor, amount):
# Setting up scales
### first param a GPIO number?
print "setting up scale"
hx = HX711(motorDict[motor]['scale'][0], motorDict[motor]['scale'][1])
hx.set_reading_format("MSB", "MSB")
hx.set_reference_unit(motorDict[motor]['reference'])
hx.reset()
hx.tare()
# start the motor
print "starting motor"
toggle_motor(1, motorDict[motor]['motor'])
while True:
try:
val_A = abs(hx.get_weight_A(1))
#val_B = hx.get_weight_B(5)
print "A: %s" % (val_A)
hx.power_down()
hx.power_up()
#time.sleep(0.01)
if val_A >= amount:
#toggle_motor(0, motorDict[motor]['motor'])
break
except (KeyboardInterrupt, SystemExit):
print("error with the scale")
# stop the motor
print "stopping motor"
toggle_motor(0, motorDict[motor]['motor'])
wiggle(4)
sleep(1)
wiggle(4)
def init_hx711(self, hx_conf):
dout = hx_conf['dout']
pd_sck = hx_conf['pd_sck']
try:
offset_A = hx_conf['channels']['A']['offset']
refunit_A = hx_conf['channels']['A']['refunit']
except (ValueError, KeyError):
offset_A = None
refunit_A = None
try:
offset_B = hx_conf['channels']['B']['offset']
refunit_B = hx_conf['channels']['B']['refunit']
except (ValueError, KeyError):
offset_B = None
refunit_B = None
hx = HX711(dout, pd_sck)
hx.set_reading_format("MSB", "MSB")
hx.reset()
if refunit_A:
hx.set_reference_unit_A(refunit_A)
if offset_A:
hx.set_offset_A(offset_A)
else:
hx.tare_A()
self.debug_msg("channel A offset: %s" % hx.OFFSET)
if refunit_B:
hx.set_reference_unit_B(refunit_B)
if offset_B:
hx.set_offset_B(offset_B)
else:
hx.tare_B()
self.debug_msg("channel B offset: %s" % hx.OFFSET_B)
return hx
def test_05_channel_name_validation(self):
test_mapping = {
"wrong_name": "C",
"integer": 1,
"long_string": "channel_A"
}
hx711 = HX711(dout_pin=5, pd_sck_pin=6, channel="A", gain=128)
for name, channel in test_mapping.items():
with self.subTest(name):
with self.assertRaises(ParameterValidationError):
hx711.channel = channel
for channel in hx711._valid_channels:
with self.subTest(
"valid gain {channel} should ot raise an error".format(
channel=channel)):
try:
hx711.channel = channel
except Exception as exception:
self.fail(
"{exception} was raised".format(exception=exception))
def __init__(self, pins=[24,23], units='mN',calweight=309.5, calfactor=-0.00320306508155):
self.pins = pins
self.units = units
self.calweight = calweight
self.calfactor = calfactor
self.lc = HX711(self.pins[0], self.pins[1])
self.lc.set_reading_format("MSB", "MSB")
print("Set Zero Weight")
self.lc.reset()
self.lc.tare()
print("Tare done. Add weight now...")
try:
self.calin = input("Weight added (grams/ [ ENTER for default ] ): ")
gravity = 9.81
print("____")
print("Input Weight = %f grams" % self.calin)
# to use both channels, you'll need to tare them both
#hx.tare_A()
#hx.tare_B()
self.calout = self.lc.get_weight(5)
print("Raw Value = %f" % self.calout)
# y = Ax + B - Assume B set by tare. Therefore A...
self.Ax = self.calin*gravity/self.calout
except SyntaxError: # User hits ENTER, enabling use of previous calibration values
self.calin = self.calweight
print("Calibration weight set to default (309.5g)")
self.Ax = self.calfactor
print("Calibration factor = %s " % self.Ax)
class load_cell:
EMULATE_HX711 = False
if not EMULATE_HX711:
import RPi.GPIO as GPIO
from hx711 import HX711
else:
from emulated_hx711 import HX711
hx = HX711(5, 6)
hx.set_reading_format("MSB", "MSB")
hx.set_reference_unit(1)
hx.reset()
#hx.tare()
def taring():
hx.tare()
def getting_weight():
chem_weight = hx.get_weight(10)
hx.power_down()
return chem_weight
import RPi.GPIO as GPIO
import time
import sys
from hx711 import HX711
def cleanAndExit():
print "Cleaning..."
GPIO.cleanup()
print "Bye!"
sys.exit()
hx = HX711(12, 16)
# I've found out that, for some reason, the order of the bytes is not always the same between versions of python, numpy and the hx711 itself.
# Still need to figure out why does it change.
# If you're experiencing super random values, change these values to MSB or LSB until to get more stable values.
# There is some code below to debug and log the order of the bits and the bytes.
# The first parameter is the order in which the bytes are used to build the "long" value.
# The second paramter is the order of the bits inside each byte.
# According to the HX711 Datasheet, the second parameter is MSB so you shouldn't need to modify it.
hx.set_reading_format("LSB", "MSB")
# HOW TO CALCULATE THE REFFERENCE UNIT
# To set the reference unit to 1. Put 1kg on your sensor or anything you have and know exactly how much it weights.
# In this case, 92 is 1 gram because, with 1 as a reference unit I got numbers near 0 without any weight
# and I got numbers around 184000 when I added 2kg. So, according to the rule of thirds:
# If 2000 grams is 184000 then 1000 grams is 184000 / 2000 = 92.
#hx.set_reference_unit(113)
hx.set_reference_unit(-429)
#if not EMULATE_HX711:
import RPi.GPIO as GPIO
from hx711 import HX711
#else:
# from emulated_hx711 import HX711
def cleanAndExit():
print ("Cleaning...")
if not EMULATE_HX711:
GPIO.cleanup()
print ("Bye!")
sys.exit()
hx = HX711(9,11) #DT,CLK
# I've found out that, for some reason, the order of the bytes is not always the same between versions of python, numpy and the hx711 itself.
# Still need to figure out why does it change.
# If you're experiencing super random values, change these values to MSB or LSB until to get more stable values.
# There is some code below to debug and log the order of the bits and the bytes.
# The first parameter is the order in which the bytes are used to build the "long" value.
# The second paramter is the order of the bits inside each byte.
# According to the HX711 Datasheet, the second parameter is MSB so you shouldn't need to modify it.
#MSB or LSB calibration
def most_common(list_):
return max(set(list_),key=list_.count)
isMSB = True
if isMSB:
import RPi.GPIO as GPIO
import time
import sys
from hx711 import HX711
# Force Python 3 ###########################################################
if sys.version_info[0] != 3:
raise Exception("Python 3 is required.")
############################################################################
# Make sure you correct these to the correct pins for DOUT and SCK.
# gain is set to 128 as default, change as needed.
hx = HX711(21, 20, gain=128)
def cleanAndExit():
print("Cleaning up...")
GPIO.cleanup()
print("Bye!")
sys.exit()
def setup():
"""
code run once
"""
print("Initializing.\n Please ensure that the scale is empty.")
scale_ready = False
gpio.setup(trig, gpio.OUT)
gpio.setup(piezo, gpio.OUT)
gpio.setup(echo, gpio.IN)
gpio.output(piezo, False)
s1 = gpio.PWM(breakfast_servo, 50)
s2 = gpio.PWM(lunch_servo, 50)
s3 = gpio.PWM(dinner_servo, 50)
play_piezo = True
s1.start(0)
s2.start(0)
s3.start(0)
# Dfrobot SEN0160 Digital Weight Sensor
hx = HX711(20, 16)
hx.set_reading_format("MSB", "MSB")
hx.set_reference_unit(2088)
hx.reset()
hx.tare()
def setServoPos(servo, degree):
global s1
if degree > 180:
degree = 180
if degree == 0:
servo.ChangeDutyCycle(0)
else:
duty = SERVO_MIN_DUTY + (degree *
(SERVO_MAX_DUTY - SERVO_MIN_DUTY) / 180.0)
import RPi.GPIO as GPIO
import time
import sys
from hx711 import HX711
def cleanAndExit():
print "Cleaning..."
GPIO.cleanup()
print "Bye!"
sys.exit()
hx = HX711(5, 6)
# I've found out that, for some reason, the order of the bytes is not always the same between versions of python, numpy and the hx711 itself.
# Still need to figure out why does it change.
# If you're experiencing super random values, change these values to MSB or LSB until to get more stable values.
# There is some code below to debug and log the order of the bits and the bytes.
# The first parameter is the order in which the bytes are used to build the "long" value.
# The second paramter is the order of the bits inside each byte.
# According to the HX711 Datasheet, the second parameter is MSB so you shouldn't need to modify it.
hx.set_reading_format("LSB", "MSB")
# HOW TO CALCULATE THE REFFERENCE UNIT
# To set the reference unit to 1. Put 1kg on your sensor or anything you have and know exactly how much it weights.
# In this case, 92 is 1 gram because, with 1 as a reference unit I got numbers near 0 without any weight
# and I got numbers around 184000 when I added 2kg. So, according to the rule of thirds:
# If 2000 grams is 184000 then 1000 grams is 184000 / 2000 = 92.
#hx.set_reference_unit(113)
#hx.set_reference_unit(92)
myAWSIoTMQTTClient.configureEndpoint(host, 8883)
myAWSIoTMQTTClient.configureCredentials(rootCAPath, privateKeyPath, certificatePath)
# AWSIoTMQTTClient connection configuration
myAWSIoTMQTTClient.configureAutoReconnectBackoffTime(1, 32, 20)
myAWSIoTMQTTClient.configureOfflinePublishQueueing(-1) # Infinite offline Publish queueing
myAWSIoTMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz
myAWSIoTMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec
myAWSIoTMQTTClient.configureMQTTOperationTimeout(10) # 10 sec
# Connect and subscribe to AWS IoT
myAWSIoTMQTTClient.connect()
data = []
hx1 = HX711(3, 4)
hx1.set_reading_format("LSB", "MSB")
hx1.set_reference_unit(-36205) #scale 1
hx1.reset()
hx1.set_offset(8388607) #scale 1 offset
def cleanAndExit():
print "Cleaning..."
GPIO.cleanup()
if myAWSIoTMQTTClient is not None:
myAWSIoTMQTTClient.disconnect()
print "Bye!"
sys.exit()
def assembleMessage(name, amount, units):
now = time.mktime(datetime.now().timetuple()) * 1000
def cleanAndExit():
print("Cleaning...")
if not EMULATE_HX711:
GPIO.cleanup()
print("Bye!")
sys.exit()
CLOCK_PIN = 1
sensors = [
HX711(0, CLOCK_PIN),
HX711(2, CLOCK_PIN),
HX711(3, CLOCK_PIN),
HX711(5, CLOCK_PIN)
]
sensors[0].set_reference_unit(referenceUnit_0)
sensors[1].set_reference_unit(referenceUnit_1)
sensors[2].set_reference_unit(referenceUnit_2)
sensors[3].set_reference_unit(referenceUnit_3)
for sensor in sensors:
# I've found out that, for some reason, the order of the bytes is not always the same between versions of python, numpy and the hx711 itself.
# Still need to figure out why does it change.
# If you're experiencing super random values, change these values to MSB or LSB until to get more stable values.
# There is some code below to debug and log the order of the bits and the bytes.
# The first parameter is the order in which the bytes are used to build the "long" value.
import RPi.GPIO as GPIO
import os
from time import sleep
from hx711 import HX711
import Adafruit_DHT
import urllib2
DEBUG = 1
# Setup the pins we are connect to
#RCpin = 24
DHTpin = 4
hx711 = HX711(
dout_pin=5,
pd_sck_pin=6,
channel='A',
gain=64
)
#Setup API and delay for Thingspeak channel
myAPI = "B6IYS9WQIKAEPJTL"
myDelay = 15 #seconds between posting data
GPIO.setmode(GPIO.BCM)
#GPIO.setup(RCpin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
def getSensorData():
RHW, TW = Adafruit_DHT.read_retry(Adafruit_DHT.DHT11, DHTpin)
import RPi.GPIO as GPIO
import time
import sys
from hx711 import HX711
# Force Python 3 ###########################################################
if sys.version_info[0] != 3:
raise Exception("Python 3 is required.")
############################################################################
# Make sure you correct these to the correct pins for DOUT and SCK.
# gain is set to 128 as default, change as needed.
hx = HX711(2, 3, gain=128)
def cleanAndExit():
print("Cleaning up...")
GPIO.cleanup()
print("Bye!")
sys.exit()
def setup():
"""
code run once
"""
print("Initializing.\n Please ensure that the scale is empty.")
scale_ready = False
time.sleep(1)
for i in range(len(text) - num_cols + 5):
text_to_print = text[i:i + num_cols]
display.lcd_display_string(text_to_print, num_line)
time.sleep(0.2)
else:
display.lcd_display_string(text, num_line)
display = lcddriver.lcd()
try:
long_string(display, "Welcome to ZoologicalFooding Project", 1)
display.lcd_display_string(":)", 2)
GPIO.setmode(GPIO.BCM)
hx = HX711(dout_pin=5, pd_sck_pin=6)
error = hx.zero()
if error:
raise ValueError('Cannot tare the scale')
reading = hx.get_raw_data_mean()
if not reading:
print('incorrect data', reading)
input('Place a known weighted object and press <enter>')
reading = hx.get_data_mean()
if reading:
known_weight_grams = input('Weight of the object: ')
fan_1 = Pin(in3, mode=Pin.OUT)
fan_2 = Pin(in4, mode=Pin.OUT)
#schakelaar voor de poort open te doen
switch = Pin(switch_pin, mode=Pin.IN)
#maak een pwm aan met timer 0 & frequentie van 5KHz
pwm = PWM(0, frequency=5000)
#creer een pwm kaneel op pin enableA met een duty cycle van 0
gate_speed = pwm.channel(0, pin=enableA, duty_cycle=0)
fan_speed = pwm.channel(0, pin=enableB, duty_cycle=0)
#deze worden niet gebruikt want de motoren bewegen pas vanaf 90% duty cycle
#de load cell amplifier
load_amp = HX711(data_pin, clk_pin)
#wordt gebruikt om de load cell waarde op null te zetten
weight_offset = 969850
def main():
#kijkt of de poort open of dicht is en sluit/opent deze als de schakelaar gebruikt wordt (zie video)
gateIsOpen = False
while True:
if (switch.value() and gateIsOpen):
print("gate is closing")
close_gate()
isOpen = False
elif (switch.value() and (not gateIsOpen)):
print("gate is opening")
def findMostProbableVegetable(labels):
for label in labels:
#print label.description," ",label.score
extractedVegetable = process.extractOne(label.description,
list_of_vegetables,
scorer=fuzz.token_sort_ratio)
if (extractedVegetable[1] > FUZZY_THRESHOLD):
return extractedVegetable[0]
return "None"
deviceID = "CART__0_40"
appID = "CART_0"
#DOUT, SCK
hx = HX711(23, 24)
broker = sys.argv[1]
topic = "estimato/" + deviceID + "/item"
GPIO.setup(4, GPIO.OUT)
camera = PiCamera()
camera.start_preview()
def on_connect(client, userdata, rc):
print("Connected with result code " + str(rc))
# Subscribing in on_connect() means that if we lose the connection and
# reconnect then subscriptions will be renewed.
client.subscribe("$SYS/#")
def on_publish(client, userdata, mid):
import RPi.GPIO as GPIO # import GPIO
from hx711 import HX711 # import the class HX711
try:
GPIO.setmode(GPIO.BCM) # set GPIO pin mode to BCM numbering
# Create an object hx which represents your real hx711 chip
# Required input parameters are only 'dout_pin' and 'pd_sck_pin'
hx = HX711(dout_pin=14, pd_sck_pin=15)
# measure tare and save the value as offset for current channel
# and gain selected. That means channel A and gain 128
err = hx.zero()
# check if successful
if err:
raise ValueError('Tare is unsuccessful.')
reading = hx.get_raw_data_mean()
if reading: # always check if you get correct value or only False
# now the value is close to 0
print('Data subtracted by offset but still not converted to units:',
reading)
else:
print('invalid data', reading)
input('Put known weight on the scale and then press Enter')
reading = hx.get_data_mean()
if reading:
print('Mean value from HX711 subtracted by offset:', reading)
known_weight_grams = 1000
try:
value = float(known_weight_grams)
print(value, 'grams')
#!/usr/bin/python3
from hx711 import HX711
import RPi.GPIO as GPIO
import statusLEDs
import statusRelaise
import time
import telegrambot
if __name__ == "__main__":
try:
GPIO.setmode(GPIO.BCM)
hx711 = HX711(dout_pin=5,pd_sck_pin=6,
gain_channel_A=64,select_channel='A')
#Offset eliminieren
print("Bitte entfernen Sie alle Gewichte von der Waage.")
time.sleep(5)
hx711.reset() #Before we start, reset the HX711 (not obligate)
hx711.zero()
#Scale Ratio setzen
print("Bitte bekanntes Gewicht auflegen!")
while True:
try:
value = float(input("Wie viel Gramm wiegt das Gewicht?"))
measures = hx711.get_raw_data_mean()
except TypeError:
print("Ungueltige Eingabe! Bitte erneut versuchen.")
continue
else:
break