In de huidige reeks artikelen richt ik me tot mijn collega's van de natuurkundige fractie. De volgende afleveringen gaan over een krachtmeter zonder schroefveer, uiteraard niet zonder het gebruik van een elastische sensor. Van de elasticiteit daarvan is echter maar heel weinig te zien. De resolutie wordt echter niet verminderd door het nauwelijks waarneembare visuele aspect, maar juist bevorderd. Hoe dat mogelijk is, vertel ik u in de nieuwe afleveringen uit de serie.
MicroPython op de ESP32, ESP8266 en Raspberry Pi Pico
vandaag
Een krachtmeter onder MicroPython – Deel 1
1. In het eerste deel gaan we in op het meetprincipe en de opbouw van de hardware.
2. In het tweede deel voegen we een groot scherm toe aan de laptop, dat via USB wordt aangestuurd.
3. In deel 3 vervangen we de USB-datakabel door draadloze overdracht.
4. Deel 4 bevat een display-eenheid met 8 LED-panelen, die ook via wifi wordt aangesloten.
5. Een Android-tablet als weergave-eenheid wordt in deel 5 voorgesteld.
De krachtsensor
Enige tijd geleden heb ik een onderdeel, waarvan er nu weer een uit dezelfde familie wordt gebruikt, al elders in een weegschaal gebruikt. In beide gevallen gaat het uiteindelijk om het meten van krachten. Dat betekent dat ook bij het bepalen van de massa met de weegschaal het ging om het meten van een kracht, namelijk de zwaartekracht F.g. Deze is via de plaatsfactor g = 9,81 N/kg gekoppeld aan de massa m van de weegstukken: Fg = g • m. Hierdoor was het mogelijk om de weegschaal te kalibreren met massastukken. Afbeelding 1 toont zo'n weegbalk. Bij de weegschaal wordt de rechterkant stevig aan de ondergrond vastgeschroefd, aan de linkerkant wordt de weegschaal bevestigd.
Afbeelding 1: Weegcel vanaf de zijkant
In het huidige geval gaat het om het direct meten van krachten. Dit wordt mogelijk gemaakt door de elastische vervorming van een weegbalk van aluminium, waarop rekstrookjes zijn aangebracht. Deze onderdelen bestaan uit flinterdunne geleiderlussen, die door het buigen van de verdunde delen van de balk, afhankelijk van hun positie, worden uitgerekt of samengedrukt, waardoor hun elektrische weerstand verandert.
Afbeelding 2: Schematische weergave van rekstrookjes
Door uitrekking worden de geleiders langer en dunner, door samendrukking gebeurt het tegenovergestelde. De lengte en de doorsnede van de geleider worden beide meegenomen in de berekening van de elektrische weerstand van een geleider. Zowel de verlenging als de verkleining van de doorsnede zorgen voor een toename van de weerstandswaarde. ρ is de soortelijke weerstand, een materiaalconstante.
Afbeelding 3: Weerstandsformule
Om ervoor te zorgen dat zelfs de kleinste veranderingen in de weerstandswaarde leiden tot een reproduceerbaar meetresultaat met een hoge resolutie, zijn de meetstrips samengevoegd tot een brugschakeling, waarvan de uitgangsspanning naar een precisieversterker wordt geleid. De uitgangsspanning daarvan hoeft nu alleen nog maar te worden gedigitaliseerd voor verwerking in een microcontroller.
Afbeelding 4: Rekstrookjes op de HX711
De bouwsteen HX711 bevat beide componenten en maakt bovendien de keuze mogelijk tussen een versterking van 128x of 64x op de differentiële ingang A en een versterking van 32x op ingang B. De overdracht van de 24-bitsADC-waarde (ADC = Analog Digital Converter) naar de microcontroller gebeurt via de Gegevens-leiding, die door 24 pulsen aan Klok wordt getakt. Tot drie extra pulsen beïnvloeden de versterkingsinstelling van de PGA (Programmable Gain Amplifier) voor de volgende meting. De hier gebruikte weegbalk kan tot 5 kg worden belast, wat overeenkomt met een maximale kracht van ca. 50 N. Samen met ingang A en versterking = 128 bereiken we een resolutie van 1 mN, wat overeenkomt met een massa van ongeveer 0,1 gram. Omdat dit al het onzekere punt is, nemen we genoegen met 10 mN als kleinste meetwaarde en krijgen we daarvoor een stabiele meetwaardeweergave. 0,01 N is immers veel meer dan men kan bereiken met krachtmeters met schroefveren.
Afbeelding 5: versterkingsinstelling via extra klokimpulsen
De software-interface voor de HX711 is de klasse HX711 uit de MicroPython-module hx711.py. Daar komen we later op terug.
Hardware
Als controller zijn zowel ESP8266- als ESP32-modellen met minimaal vier vrije GPIO's geschikt. De gemeten waarde wordt eerst weergegeven op een OLED-display. Uiteraard kan ook een ander model als weegcel worden gebruikt. Deze zijn verkrijgbaar met een weegvermogen van 100 g tot 100 kg en meer.
Omwille van ruimtegebrek heb ik in dit project gekozen voor een D1 Mini NodeMcu met ESP8266-12F WLAN-module besloten. De spanning voor de meetelektronica wordt voorlopig via de USB geleverd.
Het circuit voor de ESP8266 D1 Mini
Afbeelding 6: Krachtmeter - Schakeling
De software
Voor het flashen en programmeren van de ESP32:
Thonny of
Productie van eigen lettertypes
zeichensatz.rar Werkomgeving voor het maken van eigen tekensets
Voor het weergeven van bussignalen
SALEAE – Logic Analyzer-software (64 bit) voor Windows 8, 10, 11
Gebruikte firmware voor de ESP32:
Gebruikte firmware voor de ESP8266:
Gebruikte firmware voor de Raspberry Pi Pico (W):
RPI_PICO_W-20240602-v1.23.0.uf2
De MicroPython-programma's voor het project:
ssd1306.py Hardwarestuurprogramma voor het OLED-display
oled.py API voor het OLED-display
geometer_30.py groot tekenset voor de cijferweergave
hx711.py API voor de AX711
newtonmeter.py Het bedrijfsprogramma
MicroPython - Taal - Modules en programma's
Voor de installatie van Thonny vindt u hier een uitgebreide handleiding (Engelse versie). Daarin staat ook een beschrijving van hoe de Micropython-firmware (Stand 25-01-2024) op de ESP-chip gebrand wordt. Hoe u de Raspberry Pi Pico gebruiksklaar kunt maken, vindt u hier hier.
MicroPython is een interpretertaal. Het belangrijkste verschil met de Arduino IDE, waar u altijd en uitsluitend complete programma's flasht, is dat u de MicroPython-firmware slechts één keer aan het begin op de ESP32 hoeft te flashen, zodat de controller MicroPython-instructies begrijpt. Hiervoor kunt u Thonny, µPyCraft of esptool.py gebruiken. Voor Thonny heb ik het proces hier beschreven.
Zodra de firmware is geflashed, kunt u op een informele manier met uw controller communiceren, afzonderlijke commando's testen en direct het antwoord zien, zonder dat u eerst een heel programma hoeft te compileren en over te dragen. Dat is precies wat mij stoort aan de Arduino-IDE. Je bespaart gewoon enorm veel tijd als je eenvoudige tests van de syntaxis en de hardware, tot en met het uitproberen en verfijnen van functies en hele programmadelen via de opdrachtregel, vooraf kunt controleren voordat je er een programma van maakt. Voor dit doel maak ik ook graag steeds weer kleine testprogramma's. Als een soort macro's bundelen ze terugkerende commando's. Uit dergelijke programmadelen ontstaan dan soms hele toepassingen.
Automatisch starten
Als het programma automatisch moet starten wanneer de controller wordt ingeschakeld, kopieer dan de programmacode naar een nieuw aangemaakt leeg bestand. Sla dit bestand op onder main.py in de werkruimte en laad het naar de ESP-chip. Bij de volgende reset of inschakeling start het programma automatisch.
Programma's testen
Programma's worden handmatig gestart vanuit het huidige editorvenster in de Thonny-IDE met de toets F5. Dat gaat sneller dan met de muis op de startknop klikken of via het menu. Run. Alleen de modules die in het programma worden gebruikt, moeten zich in het flashgeheugen van de ESP32 bevinden.
Tussendoor weer eens Arduino-IDE?
Als u de controller later weer samen met de Arduino-IDE wilt gebruiken, flasht u het programma gewoon op de gebruikelijke manier. De ESP32/ESP8266 is dan echter vergeten dat hij ooit MicroPython heeft gesproken. Omgekeerd kan elke Espressif-chip die een gecompileerd programma uit de Arduino IDE of de AT-firmware of LUA of ... bevat, zonder problemen worden voorzien van de MicroPython-firmware. De procedure is altijd hetzelfde, zoals hier beschreven.
Opbouw van de meetinrichting
Voor de ophanging van de weegbalk met 12 mm x 12 mm x 75 mm hebben we nog twee aluminium profielen met dezelfde afmetingen nodig, evenals twee aluminium platen met 21 mm x 12 mm x 2,5 mm als afstandhouders. Er zijn twee aluminium U-rails nodig voor het opnemen van de printplaten waarop de controller en de HX711 worden geplaatst. Hier is de schets van de onderdelen, die ook als PDF-document gedownload kan worden. Hierin zijn de lay-out van de printplaten en het assemblagegrafiek opgenomen.
Ik heb de aluminium profielen bij de bouwmarkt gekocht. In het bovenste profiel moeten M3-schroefdraden worden gesneden voor de bevestiging van de U-rails. Ook de bevestiging van de printplaten in de U-rails gebeurt met M3-schroefdraden en afstandhouders van plexiglas (12 mm x 10 mm x 2 mm). 3 mm-schroefdraden aan de buitenkant van de U-rails dienen voor de bevestiging van een optionele afdekking.
Afbeelding 7: Mechanische opbouw van de krachtmeter
Afbeelding 8: Sensoreenheid van bovenaf
Afbeelding 9: Krachtmeter in gebruik
Afbeelding 8 toont de montage van de elektronica. Als drager dienen twee printplaten die zijn uitgerust met busstrips voor de opname van microcontrollers en HX711. Hier zijn de lay-out en het plaatsingsschema. Drie kabelverbindingen zijn in het groen aangegeven.
Afbeelding 10: Lay-out van de twee printplaten
Voor een eerste kennismaking heb ik een testopstelling gemaakt met een NodeMCU Lua Lolin V3-module ESP8266die ik net bij de hand had. Ik heb de weegbalk met mijn testkabels via een fly-wire-verbinding met het circuit verbonden.
Afbeelding 11: Testopstelling met een ESP8266 Node MCU-kaart
Deze testkabels kunnen eenvoudig worden gemaakt van een zeer flexibele siliconenkabel en een testklem in elke gewenste lengte produceren. Een enkelpolige stekkerlijst maakt aansluiting op het breadboard mogelijk. Een stukje krimpkous tegen.
Afbeelding 12: Praktische testklem met siliconenkabel
Een groot tekenset voor het OLED-display
Grote cijfers maken het aflezen van de meting aanzienlijk gemakkelijker. In plaats van de gebruikelijke acht pixels gebruiken we 30 pixels als tekenhoogte. Het bestand geometer_30.py bevat de relevante informatie hierover.
Om zelf een eigen lettertype voor het OLED-display te maken, hebben we een paar ingrediënten nodig.
1. Python voor Windows
2. freetype-py
Als Python nog niet op uw pc is geïnstalleerd, moet u dat nu doen. Download het huidige pakket Python 3.13.3 en installeer het door het bestand python-3.13.3-amd64.exe Start het programma in de downloadmap en volg de instructies van de wizard.
freetype-py is een tool die nodig is voor het converteren van een TTF-lettertype van Windows. Met Python is ook een tool ontwikkeld met de naam pip3 geïnstalleerd. Dat gebruiken we om freetype-py te installeren.
Open de opdrachtprompt en voer de volgende regel in bij de prompt.
pip3 install freetype-py
En zo maakt u uw eigen tekenset uit de TTF-voorraad van Windows.
Download het archief zeichensatz.rar en pak de inhoud uit in een willekeurige map. Om typewerk te besparen, raad ik een map met een korte naam aan in het rootpad van de harde schijf of een stick. Bij mij is dat F:\fonts.
Open vanuit Explorer een Powershell-venster in deze map door met ingedrukte Shift-toets een Rechtsklicken op de map. Klik vervolgens met de linkermuisknop op PowerShell-venster hier openen.
Afbeelding 13: Powershell-venster openen
Voer de volgende regel in bij de prompt en druk op Enter.
.\makecharset.bat geometer 30 """0123456789,-+N""" "F:\fonts\bronnen\"
Afbeelding 14: Het lettertype is klaar
Er bevindt zich nu een bestand in de map geometer_30.py met de pixelgegevens van het nieuwe lettertypetreksel. Alleen de tekens in """0123456789,-+N""", dat bespaart opslagruimte. U kunt meer tekensets downloaden van de lettertypen-map van Windows naar de map bronnen kopiëren en zoals hierboven aangegeven converteren. Let erop dat de bestandsnaam zonder de extensie .TTF wordt opgegeven.
We kopiëren nu het gegenereerde tekenset naar de werkdirectory van ons nieuwe MicroPython-project.
Eerste tests
De signaal-LED
Dan kunnen we beginnen met een paar eerste tests. Hiervoor kunnen we het testcircuit uit afbeelding 11 gebruiken, waarop de weegbalk wordt aangesloten zoals in het schakelschema in afbeelding 6.
Als signaallampje heb ik een Neopixel-led van een ledstrip gebruikt, die over was gebleven bij de bouw van de abacusklok. Dit heeft als voordeel dat met een led via een enkele stuurleiding elke gewenste kleur kan worden weergegeven.
Afbeelding 15: Neopixel-LED
Omdat de NodeMCU Lua Lolin V3-module ESP8266 Omdat de 5V van de USB niet uit de Pin Vin komt, heb ik +5V van de strip aangesloten op de 3,3 V-uitgang van de controllerboards, wat zonder problemen gaat met een LED. De ESP8266 D1 Minidie we in de krachtsensor inbouwen, levert op de 5V-pin daadwerkelijk de 5V van de USB. Din sluiten we aan D4 = GPIO2 aan.
Hieronder worden invoer in REPL vet opgemaakt, uitgaven cursief.
>>> van neopixel import NeoPixel
Het Neopixel-object bestaat uit een LED op GPIO2.
>>> led=Pin(2, Pin.OUT, value=0) # D4
>>> np=NeoPixel(led,1)
We definiëren enkele kleuren...
>>> red=(4,0,0)
>>> blauw=(0,0,4)
>>> geel=(16,8,0)
>>> off=(0,0,0)
En controleren hun werking.
>>> np[0]=rood
>>> np.write()
>>> np[0]=uit
>>> np.write()
Kleurkeuze en schrijven naar de LED vatten we samen in de functie signaal() samen.
>>> def signaal(kolom):
np[0]=col
np.write()
>>> signaal (geel)
>>> signaal(uit)
Meting van krachten
Voor de bediening van de HX711 is er een klasse die in de module hx711.py woont. Als je begint hx711.py in een editorvenster van Thonny, dan genereert het if-blok aan het einde van de listing een HX711-object met de identificatie hx.
if __name__ == "__main__":
van machine import Pin
hx=HX711(Pin(14),Pin(12,Pin.IN)) # D5, D6
Hiermee kunnen we onze eerste stappen zetten met de krachtsensor. We halen een meetwaarde op, zoals bepaald door de HX711, via de seriële lijn. Afhankelijk van de bedrading krijgen we 10 waarden per seconde (aansluitingssnelheid = GND).
>>> %Run -c $EDITOR_CONTENT
HX711 klaar op kanaal A met versterking 128
>>> hx.getRaw()
-502747
Deze waarde geldt voor de onbelaste weegbalk. Het referentiepunt is in ons geval niet de onderste bevestiging van de weegbalk, maar de haak in het bovenste deel. Wanneer de meeteenheid hangt, behoren ook de profielonderdelen die onder de weegbalk zijn gemonteerd tot de belastende onderdelen van de sensor. Deze waarde moeten we voor latere metingen als tarra in aanmerking nemen. We bepalen de tarrawaarde als gemiddelde van meerdere metingen. We geven het aantal metingen op bij het oproepen, hier 2.
>>> hx.tara(2)
-502631
Afbeelding 16: Tara registreren
Vervolgens moet de sensor worden gekalibreerd. Dat betekent dat de ruwe meetwaarde voor een bepaalde kracht, gecorrigeerd voor de tarrawaarde, moet worden omgerekend naar een krachtwaarde in Newton. We spannen dus de weegbalk vast of hangen onze meeteenheid op, starten hx711.py en roepen hx.tara(2) op. De tara-waarde wordt daardoor in het attribuut hx.tare opgeslagen en teruggegeven.
Nu moeten we de kalibratiefactor voor de omrekening naar Newton bepalen. Dat gebeurt met de methode hx.calibrateF(), waaraan we de massa van 102 g overhandigen. In het zwaartekrachtveld van de aarde werkt op deze massa, afhankelijk van de meetlocatie, een gewichtskracht van ongeveer 1 newton.
Afbeelding 17: Kalibreer met een massa van 102 g op 1 N.
Ook deze waarde wordt als attribuut hx.fcal van het HX711-object opgeslagen. Vanaf nu kunnen we krachten direct meten door de methode hx.kracht(n) oproepen. De parameter n geeft opnieuw het aantal uit te voeren metingen aan, waaruit het gemiddelde wordt berekend. Elke afzonderlijke meting duurt ongeveer 100 ms.
>>> hx.calibrateF(102)
44098.7
>>> hx.kracht(2)
1.00366
We kunnen de kalibratiefactor op elk moment opvragen en indien nodig handmatig bijstellen. Voor een eenvoudiger procedure is het raadzaam om de gevonden kalibratiefactor in de klasse HX711 bij het klasse-attribuut KFactorKracht in te voeren. Als alternatief kunnen we de waarde ook in een bestand schrijven dat we elke keer bij het opstarten uitlezen.
>>> hx.fcalFactor(44098.1)
>>> hx.kracht(2)
1.00045
>>> hx.kracht(2)
1.00288
We zien dat een bruikbaar resultaat alleen met twee decimalen kan worden weergegeven, omdat de derde decimaal al duidelijk schommelt. Maar dat is ook voldoende, want geen enkele conventionele krachtmeter met schroefveer kan tot op 0,01 N nauwkeurig meten. We zullen onze meetresultaten in de toekomst dus afronden op zes posities met twee decimalen en rechts uitgelijnd (>) weergeven met een "N" als aanduiding.
>>> "{:>6.2f} N".format(hx.kraft(2))
' 1,00 N'
Grotere tekens op het OLED-display
De module geometer_30.py heeft de volgende structuur. Na een header, waarin de opgenomen tekens, de hoogte en de maximale breedte van de tekens worden vermeld, volgt in de lijst nummer Tupel, waarvan de eerste component de huidige tekenbreedte aangeeft. Daarna volgt het pixelpatroon van het teken in de vorm van bytes-objecten in binaire weergave. Via de positie van het teken in de string chars krijgen we toegang tot het item in nummer. Eigen tekens kunnen worden gegenereerd door het bitpatroon handmatig te creëren en een pointer-teken in chars registreren.
De module moet naar het flashgeheugen van de controller worden geüpload, zodat deze kan worden aangesproken.
>>> import geometer_30 als cs
Op deze manier geïmporteerd, kunnen we de module in plaats van met het voorvoegsel geometer_30 heel kort met het voorvoegsel cs aanspreken.
chars="0123456789,-"
height=31
width=29
number=[
(17, # Tekens: 0
0b00000000000000000,
0b00000000000000000,
0b00000000000000000,
0b00000011111000000,
0b00001111111110000,
0b00011111111111000,
0b00011111111111000,
0b00111110001111100,
0b00111110001111100,
0b01111100000111110,
0b01111100000111110,
0b01111100000111110,
0b01111100000111110,
0b01111100000111110,
0b01111100000111110,
0b01111100000111110,
0b01111100000111110,
0b01111100000111110,
0b00111110001111100,
0b00111110001111100,
0b00011111111111000,
0b00011111111111000,
0b00001111111110000,
0b00000011111000000,
0b00000000000000000,
0b00000000000000000,
0b00000000000000000,
0b00000000000000000,
0b00000000000000000,
0b00000000000000000,
0b00000000000000000,
),
Om dit weer te geven, moeten we nu gewoon op het scherm vanaf de startpositie (= linkerbovenhoek van de tekenmatrix) overal een pixel plaatsen waar in het patroon een 1 staat. Dat doet de functie putNumber(). Het nummer van het patroon in de lijst krijgen we door de volgende regel. z is het weer te geven teken, de methode index() bepaalt de positie in chars.
>>> n=cs.chars.index(z)
def putNumber(n,xpos,ypos,show=True):
breedte=cs.number[n][0]
voor rij in bereik(1,cs.hoogte):
for col in range(breedte-1,-1,-1):
c=cs.number[n][row] & 1<
d.setPixel(xpos+breedte+3-col,ypos+row,c,False)
if show:
d.show()
return xpos+breedte+2
We halen de tekenbreedte op en doorlopen het patroon regel voor regel en kolom voor kolom. We lezen de kleurcode c uit, 0 of 1, en stellen de pixel verborgen (False) in op achtergrond- of voorgrondkleur, 0 of 1. Daarbij zijn twee pixels voorzien als tekenafstand. De functie geeft de x-positie voor het volgende teken terug, zodat tekens in proportionele modus kunnen worden weergegeven.
Voor de volgende tests moeten de bestanden oled.py en ssh1306.py naar het flashgeheugen van de controller worden geüpload.
>>> import geometer_30 als cs
>>> van machine import Pin,freq,SoftI2C
>>> van oled import OLED
>>> import geometer_30 als cs
>>> def putNumber(n,xpos,ypos,show=True):
breedte=cs.number[n][0]
voor rij in bereik(1,cs.hoogte):
for col in range(breedte-1,-1,-1):
c=cs.number[n][row] & 1<
d.setPixel(xpos+breedte+3-col,ypos+row,c,False)
if show:
d.show()
return xpos+breedte+2
>>> n=cs.chars.index("5")
>>> n
5
>>> n=cs.chars.index("N")
>>> n
13
>>> d.clearAll(False)
>>> pos=putNumber(5,0,0, False)
>>> pos=putNumber(13,pos,0, True)
Hiermee hebben we alle vereisten die we nodig hebben om onze krachtmeter te programmeren. De implementatie volgt in het volgende artikel.
Blijf dus op de hoogte! Tot ziens!
2 Reacties
Claus
Hallo,
toller Artikel, musste ich gleich aufbauen.
Wenn ich die Firmware flashe und alle Dateien vom Abschnitt “Die MicroPython-Programme zum Projekt” auf den ESP schreibe bekomme ich nach Programmstart die Fehlermeldung:
this is the constructor of OLED class
Size:128×32
HX711 bereit auf Kanal A mit Gain 128
HX711 initialisiert nicht
Wenn ich hingegen das Script hx711.py vom Bereich “Messung von Kräften” starte (die Zeile “from timeout import TimeOutMs” musste ich auskommentieren, da das Modul nicht gefunden wurde) bekomme ich sinnvolle Messwerte, die sich deutlich ändern, wenn ich das Gewicht ändere.
Was mache ich falsch?
DAVY
Bonjour!
Article clair, explicite, et remarquable parmi les autres: On a: Principe physique + Hard + Soft +Expérimentation !! Et chacun tour à tour explicités ! Belle pédagogie.
Félicitations et merci pour le partage.
En attendant impatiemment la suite ….