A scale without moving parts – impossible, you say? Not according to the result of my current project, which boasts incredible resolution and accuracy. From the, to the eye imperceptible, bending of an aluminium cuboid, a 24-bit ADC (analogue-digital converter), an ESP8266 or ESP32 (abbreviated in the following text ESP) and an OLED display, a digital scale is created that, in my case, can measure masses up to 1kg, with a resolution of 0.01g! This article from the series explains how it works and what tricks are behind it.
Micropython on the ESP32 and ESP8266today
Digital scale with the HX711I originally didn't think it was possible and was absolutely surprised By the result. The aluminum squad used is a so -called load cell. Two holes in the middle thin out the metal, and stretching strips are glued on the wall, in Figure 1 at the top and bottom. The material thickness is approx. 1mm there.
Figure 1: Wage cell from the side
The load cell is screwed to the right with the base plate, the strap of the scale is attached to the left.
Figure 2: Libra for 1kg
A sheet of paper of the size 10cm x 15 cm now bends the load cell so much, or rather little that the scale shows the weight of 0.9g.
How does this work? Stretching strips are wafer -thin conductor tracks that are applied to a plastic carrier. These pads are glued to a carrier material.
Figure 3: Stretching strips schematic
By bending the carrier, the conductors are stretched slightly and thus thinner and longer. This causes a change in the electrical resistance, which is known to depend on the two parameters, ρ is the specific resistance, a material constant.
Figure 4: Resistance formula
The paper on the paper is likely to trigger a bending of the 12.5mm high cuboid, which lies in the order of an atom. The resulting change of length of the measuring strip also. And that is sufficient to change the tension on the measuring bridge with the four measuring strips, two above, two below the cuboid, so far that the HX711 can derive a measurable and above all reproducible voltage change.
Figure 5: HX711 - circuit
Micropython - Language - Modules and ProgramsTo install Thonny you will find one here Detailed instructions (English version). There is also a description of how that Micropython firmware (As of 18.06.2022) on the ESP chip burned becomes.
Micropython is an interpreter language. The main difference to the Arduino IDE, where you always flash entire programs, is that you only have to flash the Micropython firmware once on the ESP32 so that the controller understands micropython instructions. You can use Thonny, µpycraft or ESPTOOL.PY. For Thonny I have the process here described.
As soon as the firmware has flashed, you can easily talk to your controller in a dialogue, test individual commands and see the answer immediately without having to compile and transmit an entire program beforehand. That is exactly what bothers me on the Arduino IDE. You simply save an enormous time if you can check simple tests of the syntax and hardware to trying out and refining functions and entire program parts via the command line before knitting a program from it. For this purpose, I always like to create small test programs. As a kind of macro, they summarize recurring commands. Whole applications then develop from such program fragments.
AutostartIf the program is to start autonomously By switching on the controller, copy the program text into a newly created blank tile. Save this file under boot.py in WorkSpace and upload it to the ESP chip. The program starts automatically the next time the reset or switching on.
Test programsPrograms from the current editor window in the Thonny-IDE are started manually via the F5 button. This can be done faster than the mouse click on the start button, or via the menu run. Only the modules used in the program must be in the flash of the ESP32.
In between, Arduino id again?Should you later use the controller together with the Arduino IDE, just flash the program in the usual way. However, the ESP32/ESP8266 then forgot that it has ever spoken Micropython. Conversely, any espressif chip that contains a compiled program from the Arduino IDE or AT-Firmware or Lua or... can be easily provided with the micropython firmware. The process is always like here described.
The circuitHere are the circuit diagrams for the project, it works free of choice for ESP32 and ESP8266. The GPIOs for connecting the HX711 are chosen so that you do not hinder the start of the ESP8266 and have the same names for both controller types. Only the connections for the I2C bus are different, but are automatically assigned By the program.
Figure 6: HX711 scale on the ESP8266
Figure 7: HX711 scale on the ESP32
The Micropython module for the HX711Like most sensor assemblies, the HX711 module also needs operating software. Unfortunately, the HX711 is not I2C-capable. The data transmission also takes place in a serial manner via the lines dot and dpclk. 24 bit plus 1 to 3 bit are always transferred for the selection of channel A or B and the setting of the reinforcement. The MSbit (Most Significant bit = high -quality bit) is the first bit the HX711.
For programming the module hx711.pydo I have this The manufacturer's data sheet used.
From time import Sleep_us, Ticks_MS
class Devicenotready(Exception):
def __init__(self):
print("Error \ nhx711 does not answer")The exception class deals with the case that the HX711 is not accessible. This is followed By the declaration of the HX711 class, that of Devicenotready inherits. With the throwing of the exception, an instance is generated and the constructor ensures the output of the error message.
class HX711(Devicenotready):
Ksela128 = const(1)
Kselb32 = const(2)
Ksela64 = const(3)
Dbits =const(24)
Frame = const(1<<Dbits)
Readydydelay = const(3000) # MS
Waitsleep =const(60) # US
Channelandgain={
1:("A",128),
2:("B",32),
3:("A",64),
}
Calibration factor=2205.5We start with a few constants. The calibration factor is determined By some weighings with various known massage pieces and a calculation tool, for example Libre Office. I will come later.
def __init__(self, dot, pdsk, ch=Ksela128):
self.data=dot
self.data.init(Fashion=self.data.IN)
self.CLK=pdsk
self.CLK.init(Fashion=self.CLK.OUT, value=0)
self.channel=ch
self.tar=0
self.cal=HX711.Calibration factor
self.WAITREADY()
K,G=HX711.Channelandgain[ch]
print("HX711 ready on channel {} with gain {}".\
format(K,G))The constructor takes the two pin objects dot and pdsk, as well as the optional channel in ch. Dout is switched as an entrance, because it should receive the data from the outcome of the HX711. The ESP specifies the pace via the DPSCK management. We declare the attributes channel, tar and cal, then we wait for the Ready signal of the HX711. If it doesn't come, then throws WAITREADY() one Devicenotready-Exception. If it worked, then we get the channel and gain setting and issue a message in the terminal. The Dictionary Channelandgain convert the channel number into plain text.
def Time-out(self,T):
begin=Ticks_MS()
def compare():
return intimately(Ticks_MS()-begin) >= T
return compareThe Closure Time-out() realizes a software timer who does not block the program as it is sleep() & Co.. The returned function compare() If a identifier is assigned to be asked about whether the time passed on has already expired in milliseconds (True) or not (false).
def ISDEVICEREADY(self):
return self.data.value() == 0The method ISDEVICEREADY() returns True when the data line is on GND potential. According to the data sheet, this is the condition if the HX711 is ready to send data. With the first positive flank on the clock line, the HX711 provides the MSbit on the DOUT line.
Figure 8: Logic 2-scan
With each additional pulse, the bits are pushed out in turn. In the meantime, the ESP must read and process the condition of the line. The ESP sets the pace through the clock. The pulse sequence is 125µs, which corresponds to a clock at approx. 8 kHz.
I have the pulse consequences with a logic analyzer and the software Logic 2 recorded. Whenever there are problems with data transmission, I like to use the DSO (digital memory oscilloscope), or a smaller tool that is cheaper for worlds Logic analyzer (La) with 8 channels. The thing is connected to the USB bus and shows using the Free softwarewhat is going on on the bus pipes. Where the shape of impulses does not matter, but only on its time sequence, a LA is worth gold. And while the DSO only provides snapshots of the curve, you can feel the LA over a long time and then zoom yourself into the interesting places. You can find a description of the device in the blog post "Logic Analyzer Part 1: Make I2C signals visible"By Bernd Albrecht. There it is also described how to scan the I2C bus.
After reading the 24 data bits, one to three more pulses are used pdsk issued, the tax bits. You have the following meaning:
Figure 9: Meaning of the control pulses
def WAITREADY(self):
delayover = self.Time-out(Readydydelay)
while need self.ISDEVICEREADY():
IF delayover():
raise Devicenotready()The name is program, WAITREADY() waiting for a true of ISDEVICEREADY(), but previously put the timer on the value in Readydydelay, that's three seconds. If Dout does not go to low during this time, one will be one Devicenotready-Sexception thrown. This brings off the calling program if it does not intercept the exception.
def Conpricerult(self,Val):
IF Val & Minval:
Val -= Frame
return ValThe HX711 sends the data as a two-complement values. Conpricerult () actually recognizes negative values in the set MSbit, the bit 23. If it is set, the level 2 is the level 2 of the24 Subtracted to really get a negative number.
0xc17ac3 = 12679875 has a set MSbit
12679875 - 0x1000000 = -4097341
def clock(self):
self.CLK.value(1)
self.CLK.value(0)clock() just generates a positive pulse of 12.4µs on the PDSCK line.
def channel(self, ch=None):
IF ch is None:
ch,gain=HX711.Channelandgain[self.channel]
return ch,gain
Else:
assert ch in [1,2,3],\
"Wrong channel number: {} \ n \
Correct is 1.2 3 ".format(ch)
self.channel=ch
IF need self.ISDEVICEREADY():
self.WAITREADY()
for n in range(Dbits + ch):
self.clock()You overlook channel() No argument, then the function delivers the current channel and gain values. The Dictionary Hx711.channelandgain Take over the translation into plain text.
Once a channel number has been handed over, we check for the correct area, check whether the HX711 is ready and then push the corresponding number of pulses onto the PDSCK line, 24 plus the tax bits.
def traw(self, conv=True):
IF need self.ISDEVICEREADY():
self.WAITREADY()
raw = 0
for B in range(Dbits-1):
self.clock()
raw=(raw | self.data.value())<< 1
self.clock()
raw=raw | self.data.value()
for B in range(self.channel):
self.clock()
IF conv:
return self.Conpricerult(raw)
Else:
return rawThe raw values that the HX711 delivers are By traw() received. Becomes True Or not handed over an argument at all, then the return value is pink, i.e. an integer with a sign. With false the value Bloody returned, as it corresponds to the bit sequence, raw.
We are waiting for the sending of the HX711 and set the receiving buffer to 0.
In the for loop we send 23 pulses on PDSCK. With each run, we are in the place of the LSBIT (LEAST Significant bit = low -quality bit) the condition on the data line and then push the bits By one position to the left. The first received bit moves to position 23, the MSbit. After another clock pulse, the HX711 pushes the LSbit onto the data line, which we only on the LSbit of raw or have to. In addition to competition, the tax bits for the next measurement must then be clocked.
def mean(self, n):
S=0
for I in range(n):
S += self.traw()
return intimately(S/n)To smooth the noise of the values, we not only use a single measured value, but the mean from several measurements. That gets the method mean(), which we hand over the number of individual measurements.
def tara(self, n):
self.tar = self.mean(n)The unpolluted scale naturally also delivers an ADC value, the Tara. We always call the method when booting the weighing program in order to be able to set the display to 0. The Tara value is in the attribute self.are saved so that the method Dimensions() has available, n is again the number of individual measurements.
def Dimensions(self,n):
G=(self.mean(n)-self.tar) / self.cal
return GThe method Dimensions() pulls the Tara off the measured value and then calculates the true measured value in grams By division with the calibration factor. I will show how it is determined later.
def Cal factor(self, F=None):
IF F is need None:
self.cal = F
Else:
return self.calDuring the calibration, it is an advantage if you can handle the calibration factor manually without having to newly upload the HX711.PY module to the ESP every time. The current value will be returned without an argument.
def wake up(self):
self.CLK.value(0)
self.channel(self.channel)
def tosleep(self):
self.CLK.value(0)
self.CLK.value(1)
Sleep_us(Waitsleep)wake up() and tosleep() tickle the HX711 from sleep mode, or put it in it. The signal sequence on the lines is specified By the data sheet of the HX711.
A big character set for the OLED displayLarge digits make it easier to read the measurement. Instead of the usual eight pixels, we use 30 as a sign. The file geometer_30.pyContains the relevant information.
And so you make your own character set from the TTF supply from Windows.
Download the archive zeichensatz.rarDown and unpack the content into any directory. To save tipping, I recommend a list with a short name in the root path of the hard drive or a stick. With me it is F: \ fonts.
Open a PowerShell window in this directory from the Explorer By making a right click on the directory with a push button pressed. Then left click on Open the PowerShell window here.
Figure 10: Open PowerShell window
Enter the following line at the prompt and press Enter:
. \ Makecharset.bat Britannic 30 "" 0123456789, -+KG "" "F: \ fonts \ sources \"
Figure 11: The character set is ready
There is now a file in the directory britannic_30.py With the pixel data of the new character set. Only the characters were implemented in "" "0123456789, -+KG" ", that saves storage space. You can get other sign rates from the fonts-List of Windows in the directory sources Copy and convert as specified above. Please note that the file name is specified without the addition.TTTF.
The operating software of the LibraThe program scale.py accesses four external modules that have to be uploaded to the flash of the ESP before starting, hx711.py,oled.py,SSD1306.PYand geometer_30.py.
From time import sleep
From OLED import OLED
import Geometer_30 AS CS
import sys
From HX711 import HX711About the variable sys.platform an ESP can determine its himself. Then the GPIO pins are declared for the I2C bus.
IF sys.platform == "ESP8266":
I2C=Softi2c(scl=Pin code(5),sda=Pin code(4),freq=400000)
elif sys.platform == "ESP32":
I2C=Softi2c(scl=Pin code(22),sda=Pin code(21),freq=400000)
Else:
raise Unkownporterror()We instantiate a display object, delete the display and declare the PIN objects for the connection to the HX711, also button, the instance for the Tara key.
IF sys.platform == "ESP8266":
I2C=Softi2c(scl=Pin code(5),sda=Pin code(4),freq=400000)
elif sys.platform == "ESP32":
I2C=Softi2c(scl=Pin code(22),sda=Pin code(21),freq=400000)
Else:
raise Unkownporterror()The function Putnumber() positions the pixel pattern of the character with the number n (based on the extract generated above, not Ascii). The position of the top left corner of the pattern is in XPOS, YPOS.
def Putnumber(n,XPOS,YPOS,show=True):
width=CS.number[n][0]
for row in range(1,CS.Height):
for col in range(width-1,-1,-1):
C=CS.number[n][row] & 1<<col
D.setpixel(XPOS+width+3-col,YPOS+row,C,False)
IF show:
D.show()
return XPOS+width+2A look at the file geometer_30.pyexplains the procedure. In the string chars the characters are listed. The index in the string is the drawing number. The "-" sign is therefore number 11, the "0" is number 0. In the list number this number identifies the Tupel With the width information and the pixel matrix. This is now scattered By line column for columns and the pixel is set when a 1 has been found. That happens hidden. Only if show the value True Has, the entire buffer is sent to the Display. The return value is the next free drawing position.
Figure 12: Matrix for the sign 0
The drawing position is set to 0, as a start information I give a number of "-" signs. Then the ESP tries to contact the HX711. If this succeeds, we wake it up, channel A with Gain 128 and see the TARAWALT that in the attribute self.are lands.
POS=0
try:
for n in range(8):
POS=Putnumber(11,POS,0)
HX = HX711(dot,dpclk)
HX.wake up()
HX.channel(1)
HX.tara(25)
print("Libra started")
except:
print("HX711 does not initialize")
for n in range(8):
POS=Putnumber(0,POS,0)
sys.exit()
freq(160000000)If the connection does not work, we get a message in the terminal and a series of zeros in the display.
160MHz is for the ESP8266 Topspeed, the ESP32 also packs 240 MHz.
Then it goes into the main loop. We see if the Tara key is pressed, confirm this with a series of commas on the display and get a new Tara value. This feature is useful because the weighing cell is subject to a temperature drift and the zero point can be readjusted at any time.
while 1:
IF button.value() == 0:
D.clearall(False)
POS=0
for n in range(14):
POS=Putnumber(10,POS,0)
HX.tara(25)The format string for the output is fed with the measured value. Disconnect the display, delete the drawing position to 0, decimal point with a comma and write the characters in the buffer up to the penultimate.
M="{: 0.2f}".format(HX.Dimensions(10))
D.clearall(False)
POS=0
M=M.replac(".",",")
for I in range(len(M)-1):
Z=M[I]
n=CS.chars.index(Z)
POS=Putnumber(n,POS,0, False)With the output of the last character, the buffer content is sent to the display. The next round starts after half a second break.
Z=M[len(M)-1]
n=CS.chars.index(Z)
POS=Putnumber(n,POS,0)
state=(button.value() == 0)
sleep(0.5)You can download here.
Calibrate the scaleFigure 13: Mass pieces for calibration of the scale
You need a few mass pieces and, if necessary, a kitchen or letter scale if the mass pieces are not calibrated. In this case, you can make a lay of fat nuts or screws or the like. Of course, the masses must be determined with a different scale before use.
Figure 14: Calibrate on the ESP8266
Start the program now scale.pyIn Thonny and break in the main loop Ctrl+C away. The HX711 object is under HX instantiated and accessible from the terminal console. We start with the following commands.
>>> HX.tara(50)
>>> HX.tar
562708
>>> HX.mean(25)-HX.tar
-17
>>> HX.mean(25)-HX.tar
8We subtract the Tara value from the average of 25 individual measurements. The results should be between -50…+50 if the scales are not loaded.
Now we lay the mass pieces one after the other and in groups, so that it is increasingly stressed. Every time we start the last command again and write down the mass in Grams and the value displayed in the terminal.
The Table Let us enter in Libre Office Calc or another program and display the measurement curve together with the determination (correlation coefficient) and the formula.
Figure 14: Calibration curve
The correlation coefficient R2 Is in fact 1, that speaks for the precision of our measurement. We can neglect the axis section of -43,... with an order of 100, 000. The slope factor 1104 of the straight line is our sought -after calibration factor. Now share this value to the object HX with.
>>> HX.Cal factor(1104)
>>> HX.Cal factor()
1104If you are now the method Dimensions() Call up, a value of 0.0... should be displayed.
>>> HX.Dimensions(25)
0.0244565Wear the calibration factor in the file hx711.py one, upload them to the ESP and start the program scale.py new.
Calibration factor=1104If the mass is displayed when the masses are put on, they have won and can pound on the shoulder.
If the displayed value is slightly next to the expected weight, you can still file a little on the calibration factor value. If you enlarge it, the mass value will fall and vice versa.
Comments