Dit bericht is ook als PDF-document beschikbaar.
Hoewel er een hele reeks sensoren beschikbaar is om temperatuur, vochtigheid, luchtdruk, verlichtingssterkte te meten... moeten we in de gereedschapskist graven om een sensor voor neerslag te bouwen. Het is eenvoudigweg een kwestie van het registreren van relatief kleine hoeveelheden vloeistoffen, die geen continue stroom vertegenwoordigen, maar in de ware zin van het woord in druppeltjes verschijnen. Deze druppels moeten worden opgevangen. Wanneer het potje gevuld is met druppels, moet het automatisch geleegd worden en moet dit proces geregistreerd worden. Ik heb het principe gekopieerd van commerciële apparaten op internet. Er is een schudder met twee kommen gemonteerd zodat deze eenvoudig kan worden gedraaid en gekanteld wanneer een bepaald vulniveau wordt bereikt. Dit kantelproces moet nu door geschikte sensoren worden geregistreerd. Hoe het ging, inclusief verkeerde afslagen, ontdek je in de volgende afleveringen van de serie
MicroPython op de ESP32 en ESP8266
Vandaag [1]
De ESP32 als regenmeter – Deel 1
In de aflevering van vandaag verzorgen we de werking van het project, bekijken we hoe reed-contacten werken en creëren we een eerste klein testprogramma dat we in de volgende twee afleveringen zullen uitbreiden. Om dit te doen, gebruiken we de trukendoos van MicroPython. Je leert over interrupts, contactbounce en hoe je dit programmatisch kunt uitschakelen. Ten slotte zullen we de bestanden met de gemeten waarden via FTP met behulp van threading-technologie naar de pc overbrengen.
mechanica
De wip
De sensor voor het meten van de hoeveelheid regen is een wip met twee bakken.
Figuur 1: Basisgedeelte van het apparaat
Hier is de rocker al in het onderste deel van de meetbuis geïnstalleerd. Ik gebruikte een afdekking van een PVC-rioolbuis van 100 gauge. Er zijn twee openingen gezaagd zodat het water weg kan lopen.
Figuur 2: Regenwippatroon
Figuur 2 toont het patroon van de rocker, gemaakt van 2 mm plexiglas. Het 1:1-sjabloon in de vorm van een PDF-bestand, kan worden gedownload. Voor het lijmen heb ik PLEXIGLAS®-lijm “Acrifix 192” gebruikt. Het vult gaten op en hardt uit onder UV-licht of gewoon daglicht. De sjabloondelen heb ik met een wateroplosbare lijmstift op het acrylglas gelijmd. Na het zagen en boren verwijder je het papier eenvoudig weer. Vergeet niet de te lijmen plekken schoon te maken met aceton of isopropanol.
De positie van het 1,5 mm gat voor de as gemaakt van 1,4 mm koperdraad (de as mag niet roesten, gebruik dus geen ijzer) bepaalt hoe gemakkelijk de tuimelaar kantelt. Dit neemt toe naarmate het gat zich hoger boven de grond bevindt. Ik gebruik het bovenste gat en krijg een capaciteit van ca. 2,4 cm³ tot de tuimelaar omvalt. We zullen later bekijken hoeveel regen dit betekent, afhankelijk van het gebied.
Wat kun je verkeerd doen? De resolutie van de volumemeting is beter als de wip zo licht mogelijk is. Gebruik dus zo dun mogelijk materiaal en zo min mogelijk lijm. Mijn eerste poging om de rocker uit blik of koperplaat te maken was een totale flop. Het volume van de kuipen was niet voldoende om de wip te doen omvallen, omdat de constructie veel te zwaar was.
De ophanging van de rocker is eveneens van acrylglas. De zijpanelen worden op de 6 mm dikke bodemplaat geschroefd zodat het ding uit elkaar kan worden gehaald. De afmetingen zijn te vinden in Figuur 3.
Figuur 3: Tuimelbeugel
Om te voorkomen dat de rocker tegen de zijwanden schuurt, heb ik er kleine plexiglas schijfjes tussen geplaatst.
Figuur 4: Rocker vanaf de zijkant
Figuur 5: Wip, gezien vanuit het noordoosten
Om de neerslag gericht in de bakken te laten belanden, moet deze over een gebied van bekende grootte worden opgevangen en via een trechter naar net boven de wip worden geleid. Uiteraard mag slechts één van de twee helften tegelijk worden gevuld. Er zijn drie dingen waarmee u rekening moet houden.
● De kuipen moeten breed genoeg zijn, zodat er niets misgaat.
● De bovenrand van de scheidingswand moet ver genoeg verwijderd zijn van de vallijn van de waterdruppels.
● En omdat grote trechters meestal dikkere uitlaatbuizen hebben, moest ik het mondstuk van een siliconenpatroon gebruiken om een dunnere uitlaat te creëren. Het mondstuk werd eenvoudig met siliconen in de trechter gelijmd.
Een rioolbuis van 100 mm die de trechter ondersteunt, is op lengte gezaagd zodat de trechter in de juiste positie kan worden geplaatst. Figuur 5 toont de drie componenten van de mechanica.
Figuur 6: De mechanische onderdelen van de regenmeter
Zo ziet het voltooide apparaat eruit. De opening in de buis maakt controle mogelijk bij het nauwkeurig uitlijnen van de trechter. Indien nodig kan het uitgezaagde stuk voorzien worden van scharnieren en gebruikt worden als deur.
Figuur 7: Meetstation gemonteerd
Kantelbeweging registreren
Laten we eens kijken naar de bepaling van de kantelbeweging. Uit metingen met een pipet is gebleken dat de schudder naar rechts en links kantelt met iets verschillende vulhoeveelheden, 2,4 cm³ en 2,5 cm³. Deze omstandigheid was kennelijk het gevolg van een ongelijkmatige lijmaanbrenging of andere asymmetrieën. Beide stabiele eindposities moesten dus detecteerbaar zijn. Aanvankelijk was ik van plan een MPU6050-versnellingsmeter te gebruiken in de vorm van een GY 521-module. De vier benodigde kabels hinderden echter zoveel met het kantelen van de rocker, dat ik daar van moest afzien. Reflecterende lichtschermen waren voor mij te omvangrijk en daarom heb ik uiteindelijk reedcontacten gebruikt.
Dit zijn kleine, magnetisch bediende schakelaars in een glazen buisje van 2 x 13 mm. Het gemeenschappelijke aan deze dingen zijn de stijve verbindingsdraden. Ik heb vier van de contacten gedood, want als je het te dicht bij het glas buigt, zal het onmiddellijk versplinteren en het onderdeel doden.
Figuur 8: Reedcontact
Uiteindelijk is het ons gelukt om twee dingen met tweecomponentenplamuur aan één zijwand van de houder te bevestigen. Ziet er wild uit, maar werkt goed. Het is het beste om de lijn op dezelfde manier te bevestigen.
Figuur 9: Locatie van contacten en magneet
Op de rocker (Acrifix) wordt een kleine neodymium schijfmagneet geplakt en de contacten worden overeenkomstig deze positie uitgelijnd. Figuur 10 illustreert hoe de reed-contacten werken en legt uit waarom dit type magneet niet precies vóór het contact mag worden geplaatst.
Figuur 10: Hoe een reedcontact werkt
Het contact is open buiten magnetische velden (1). De contactveren zijn gemaakt van ferromagnetisch materiaal, waarschijnlijk ijzer of een overeenkomstige legering. De polen van een schijfmagneet zitten op de snijvlakken. Als je het reedcontact nadert, wordt de ijzerdraad (onderkant) door magnetische invloed een magneet (zuidpool) en trekt de tweede contactveer aan. Het contact sluit (2).
Als je de schijfmagneet centraal onder het contact zou schuiven, worden soortgelijke polen in de veren beïnvloed. Omdat ze elkaar afstoten kan het contact niet sluiten (3).
Kleine staafmagneten kunnen direct parallel aan het contact worden geplaatst. Doordat dan verschillende polen in de contactveren worden beïnvloed, sluit het contact (4).
Hardware
Voor beide controllerfamilies, ESP32 en ESP8266, moet je eerst nadenken over de GPIO-pinnen die gebruikt kunnen worden. Sommige ervan zijn geïntegreerd in het opstartproces en kunnen daarom niet zonder beperkingen worden gebruikt. Naast drie IRQ-ingangen, een knopingang en een LED-uitgang hebben we ook de I2C- en SPI-bussen nodig, die alleen al 6 pinnen bezetten. De tabellen geven informatie over het gebruik van de pinnen. Bij de ESP8266 blijven naast de buslijnen slechts 3 GPIO-pinnen over, waarvan D0 = GPIO16 niet IRQ-compatibel is. De “kleintjes” zijn daarom uitgesloten van ons project.
Maar er is ook een probleem met de ESP32. Pin 12 mag tijdens het opstarten niet HOOG staan, anders start de controller niet op. Helaas is deze aansluiting de MISO-lijn van de SPI1-bus en wordt deze door de slave naar 3,3V getrokken. Daarom is SPI1 taboe. Gebruik dus SPI2 of Soft-SPI. Daar komen we in het volgende bericht op terug.
Laten we verder gaan met de onderdelen die nodig zijn voor het project. In de tabel staan alle componenten vermeld die nodig zijn gedurende het hele project. In deze eerste aflevering worden de grijs gemarkeerde in eerste instantie niet gebruikt.
|
1 |
ESP32 Dev Kit C niet gesoldeerd of ESP32 Dev Kit C V4 ongesoldeerd of |
|
1 |
|
|
1 |
|
|
1 |
SPI-lezer Micro-geheugen SD TF-kaart Geheugenkaart Shield-module |
|
1 |
SD-kaart bijvoorbeeld 8GB |
|
1 |
|
|
1 |
|
|
1 |
|
|
1 |
LED |
|
1 |
Weerstand 220Ω |
|
2 |
Weerstand 10kΩ |
|
1 |
Microschakelaarknopset - 180 stuks, verschillende maten, veelzijdige knoppen voor elektronica |
|
optioneel |
Tabel 3: Componenten
Van de 10 reedcontacten in de set zijn er 2 nodig (of zoals ik, zes).
Het schakelschema in figuur 11 laat zien hoe de onderdelen zijn aangesloten.
Figuur 11: Regenmetercircuit
De software
Voor het knipperen en programmeren van de ESP32:
Thonny of
Firmware gebruikt voor een ESP32:
Micropython-firmware downloaden
De MicroPython-programma's voor het project:
time-out.py Niet-blokkerende softwaretimer
oled.py OLED-API
ssd1306.py OLED-stuurprogramma
regenmes.py Demoprogramma
MicroPython - taal - modules en programma's
Om Thonny te installeren kun je er hier een vinden gedetailleerde instructies (Engelse versie). Er staat ook beschreven hoe u dit kunt doen Micropython-firmware (vanaf 18 juni 2022) op de ESP-chip verbrand wordt.
MicroPython is een tolktaal. Het belangrijkste verschil met de Arduino IDE, waarbij je altijd en uitsluitend hele programma's flasht, is dat je de MicroPython-firmware in het begin maar één keer hoeft te flashen op de ESP32, zodat de controller de MicroPython-instructies begrijpt. U kunt hiervoor Thonny, µPyCraft of esptool.py gebruiken. Ik heb het proces voor Thonny hier beschreven.
Zodra de firmware is geflasht, kunt u een informeel gesprek met uw controller voeren, individuele opdrachten testen en onmiddellijk de reactie zien zonder eerst een heel programma te hoeven compileren en overbrengen. Dat is precies wat mij stoort aan de Arduino IDE. U bespaart veel tijd als u via de opdrachtregel eenvoudige syntaxis- en hardwaretests tot en met het uitproberen en verfijnen van functies en volledige programmaonderdelen kunt uitvoeren voordat u er een programma van bouwt. Voor dit doel maak ik altijd graag kleine testprogramma's. Als een soort macro combineren ze terugkerende opdrachten. Uit dergelijke programmafragmenten ontstaan soms hele applicaties.
Automatisch starten
Als u wilt dat het programma autonoom start wanneer de controller wordt ingeschakeld, kopieert u de programmatekst naar een nieuw aangemaakt leeg bestand. Sla dit bestand op als main.py in de werkruimte en upload het naar de ESP-chip. De volgende keer dat u reset of inschakelt, start het programma automatisch.
Programma's testen
Programma's worden handmatig gestart vanuit het huidige editorvenster in de Thonny IDE met behulp van de F5-toets. Dit is sneller dan klikken op de startknop of het menu gebruiken loop. Alleen de modules die in het programma worden gebruikt, moeten in de flash van de ESP32 staan.
Arduino IDE weer tussendoor?
Als je de controller later weer samen met de Arduino IDE wilt gebruiken, flash je het programma gewoon op de gebruikelijke manier. De ESP32/ESP8266 vergat toen echter dat hij ooit MicroPython sprak. Omgekeerd kan elke Espressif-chip die een gecompileerd programma bevat uit de Arduino IDE of de AT-firmware of LUA of ... eenvoudig worden voorzien van de MicroPython-firmware. Het proces is altijd zo hier beschreven.
Een eerste test
Het is het beste om hiermee te beginnen Upload de volgende bestanden naar de ESP32-flitser:
oled.py, ssd1306.py, ds3231.py en timeout.py
Als alles gemonteerd is, starten we met de eerste tests. In VERV laten we de volgende regels invoeren. Het mooie van MicroPython is dat je het effect van opdrachten vanaf de opdrachtregel kunt testen voordat je ze in een programma opneemt. Dat is precies wat wij nu doen. We plaatsen de rocker in de linkerpositie. De vermeldingen zijn vetgedrukt, het systeem antwoordt cursief.
>>> from machine import Pin
>>> reedR = Pin(16,Pin.IN)
>>> reedL = Pin(17,Pin.IN)
>>> reedR()
1
>>> reedL()
0
Na het inklappen van de rocker:
>>> rietR()
0
>>> rietL()
1
Dus dat werkt. Bij het opvragen van de niveaus gebruik ik de eigenschap pin-objecten opvraagbaar, dat wil zeggen opvraagbaar zijn. Dit gebeurt via de methode Pin.__bel__() maakt het mogelijk. Ze behoort tot de zogenaamde Magische methoden en zorgt ervoor dat het object als een functie kan worden aangeroepen. De volgende instructies moeten daarom als synoniemen worden gebruikt.
>>> rietR(1)
>>> reedR.waarde(1)
>>> reedR.on()
Of
>>> rietR()
0
>>> reedR.waarde()
0
>>> reedR.on()
0
Volgende test: I2C-bus. We binden de module SoftI2C één, instantiëer een object, i2c en kijk wie er in de bus is vertegenwoordigd.
>>> van machine-import Pin, SoftI2C
>>> i2c=SoftI2C(scl=Pin(22),sda=Pin(21),freq=100000)
>>> i2c.scan()
[60, 87, 104]
Het zal je waarschijnlijk verbazen dat er drie adressen van randapparatuur worden gevonden, aangezien we maar twee modules op de bus hebben. Ja, maar - naast de RTC-chip heeft de DS3231-module ook een 32Kb = 8KB EEPROM met het hardware-adres 87 = 0x57 op het bord. Van belang voor ons zijn de 60 = 0x3C (OLED) en de 104 = 0x68 (DS3231). De EEPROM zou bijvoorbeeld kunnen worden gebruikt om configuratiegegevens permanent op te slaan. Het werkt dus ook.
Oled-scherm: Bij het instantiëren passeren we het I2C-object en vertellen de API dat ons scherm 64 pixels hoog is.
>>> d=OLED(i2c,hoogtew=64)
dit is de constructor van de OLED-klasse
Afmeting: 128x64
>>> d.writeAt("Hallo wereld",3,0)
13
In het midden van de bovenste regel staat "Hallo wereld". De geretourneerde waarde 13 is de volgende vrije schrijfpositie in de regel.
De RTC (Real Time Clock) bevindt zich ook op de I2C-bus. We geven daarom ook de I2C-instantie door aan de constructor van het RTC-object. Vervolgens stellen we de datum en tijd in en halen we de tijd op. Er moet een tupel met de volgende zeven waarden worden doorgegeven (jaar, maand, dag, dag van de week, uur, minuut, seconde). Ook de zeer uitgebreide module is de moeite waard ds3231.py om het van dichterbij te bekijken.
>>> rtc=DS3231(i2c)
DS3231 bereit @ 0x4C
>>> rtc.DateTime((2024,6,14,5,14,19,30))
>>> rtc.Time()
[14, 19, 32]
De ESP32 beschikt ook over een RTC, maar beschikt niet over een alarmtimer. Om een wekkerfunctie te krijgen moeten we gebruik maken van de DS3231 en – kortom programma-onderbrekingen IRQS. Ze worden gebruikt om een externe gebeurtenis aan het lopende programma te melden en om de werking ervan aan te vragen door het programma onmiddellijk te onderbreken (interruptverzoek).
De tuimelcontacten en de RTC kunnen dergelijke gebeurtenissen activeren door het niveau op een GPIO-pin te wijzigen (pin-change IRQ). We moeten voor elke gebeurtenis een GPIO-invoer definiëren. De IRQ kan worden ingeschakeld nadat een interrupt service routine (ISR) is gedefinieerd. In de parameter pin Het triggerpin-object wordt door het systeem doorgegeven. De ingangen zijn aangesloten op externe pull-ups van 10kOhm omdat de interne een te hoge impedantie hebben. Dit verbetert de helling – dat is wat de DSO (Digital Storage Oscilloscope) mij vertelde.
>>> reedR = Pin(16,Pin.IN)
>>> reedL = Pin(17,Pin.IN)
led=Pin(2,Pin.OUT,value=0)
>>> def pinIRQ(pin):
global source
if pin==reedL:
source="L"
led(0)
elif pin==reedR:
source="R"
led(1)
>>> reedR.irq(handler=pinIRQ, trigger=Pin.IRQ_FALLING)
<IRQ>
>>> reedL.irq(handler=pinIRQ, trigger=Pin.IRQ_FALLING)
<IRQ>
Bij het inschakelen wordt de referentie naar de ISR overgedragen en wordt de dalende flank als trigger ingesteld.
Als de wip nu met de hand wordt gekanteld, brandt de LED bij een kanteling naar rechts en gaat uit bij een kanteling naar links. – Griezelig, toch? – Er loopt geen programma en de contacten zijn niet rechtstreeks op het LED-circuit aangesloten. De IRQ's zijn dus ook actief als er geen hoofdprogramma actief is. Wat nu wordt onderbroken is VERV, de Reed Eval Print Loeps. En dus schakelen we de magie weer uit.
>>> reedL.irq(handler=None)
<IRQ>
>>> reedR.irq(handler=None)
<IRQ>
Deze gebruiken wij om op te ruimen als we het programma verlaten en een schone kamer achterlaten. We kunnen dit proces activeren door op de knop op GPIO4 te drukken - later, niet nu.
Voor de Hartslag (teken van leven) tijdens het draaien van de hoofdlus gebruiken we de LED en een niet-blokkerende softwaretimer. Dit draait op de achtergrond zonder de uitvoering van de lus te blokkeren. De magie is hier alles in één Sluiting. Dit is een functie ingekapseld in een omringende functiedefinitie. Omdat de innerlijke functie variabelen uit de omringende functie gebruikt, blijven zowel de innerlijke functie als de variabelen in leven nadat ze de omringende functie hebben verlaten. Normaal gesproken worden alle ingewanden van een functie gepureerd als ze deze verlaten. Oh mystieke MicroPython – Ommm!
De omringende functie wordt hier aangeroepen TimeOutMs(). Ze woont in de module time-out.py, van waaruit we ze importeren. In TimeOutMs() leeft de functie vergelijken(), dat het doorgegeven argument 5000 en ook de huidige status van de timertik ophaalt. Zolang het verschil tussen andere tijdstempels en de aan het begin geregistreerde timertik niet groter is dan 5000, levert de functie vergelijken() retourneert de waarde False, anders True. TimeOutMs() retourneert een verwijzing naar bij het afsluiten vergelijken() terug en maakt zo de sluiting onsterfelijk. Deze referentie wijzen wij toe aan de identifier knippert nu en kan de functie gebruiken vergelijken() onder het pseudoniem knippert nu bel op elk gewenst moment.
>>> from timeout import TimeOutMs
>>> jetztBlinken=TimeOutMs(5000)
>>> jetztBlinken()
False
>>> jetztBlinken()
False
>>> jetztBlinken()
True
Na vijf seconden krijgen we het resultaat WAAR. De functiedefinitie is nogal mager, maar het onderzoeken waard. Om dit te doen, opent u eenvoudig het bestand time-out.py in een editorvenster.
Het programma
Met deze handtesten hebben we eigenlijk al het hele programma besproken. Alle elementen verschijnen opnieuw in misschien wel een iets andere volgorde, met een paar kleine toevoegingen waar commentaar op wordt gegeven.
# regenmesser.py
from oled import OLED
from machine import Pin, SoftI2C
from time import sleep_us, sleep, sleep_ms
from ds3231 import DS3231
import sys
from timeout import TimeOutUs, TimeOutMs
# externe 10k-Pullups bringen steilere Flanken!
reedR = Pin(16,Pin.IN) # rechts prellt 75us
reedL = Pin(17,Pin.IN) # links kein Prellen
key=Pin(4,Pin.IN,Pin.PULL_UP) # Tasteneingang an GPIO4
# mit internem Pullupwiderstand
led=Pin(2,Pin.OUT,value=0)
i2c=SoftI2C(scl=Pin(22),sda=Pin(21),freq=100000)
i2cDevices=i2c.scan()
i2cNamen={ # Das Dictionary erleichtert die Identifikation
0x57: "DS3231.EEPROM 32Kb",
0x68: "DS3231.RTC",
0x3C: "OLED",
0x40: "SHT21",
}
print("I2C-Devices @ ")
for i in i2cDevices: # Nummer in Hexcode und Klartext wandeln
print(hex(i),i2cNamen[i])
print()
d=OLED(i2c,heightw=64)
rtc=DS3231(i2c)
source="*"
# Inhalt der Kippschalen in ccm
cLinks = 2.4 # ccm
cRechts = 2.5
# Trichter Durchmesser d=10,9cm
area=(10.9/2)**2 * 3.1415 # Trichterfläche
bucketHour=0 # Der Sammeleimer
# IRQ-Service-Routine
def pinIRQ(pin):
global source # Damit der neue Wert die ISR verlassen kann
if pin==reedL:
source="L"
elif pin==reedR:
source="R"
def shutdown(): # Funktion zum Aufraeumen beim Beenden
reedL.irq(handler=None)
reedR.irq(handler=None)
print("von User abgebrochen")
# Pin Change IRQ scharfschalten
reedR.irq(handler=pinIRQ, trigger=Pin.IRQ_FALLING)
reedL.irq(handler=pinIRQ, trigger=Pin.IRQ_FALLING)
jetztBlinken=TimeOutMs(2000) # Das erste Blinken initiieren
while 1: # Hauptschleife
Y,M,D,_,h,m,s=rtc.DateTime() # Datum und Zeit holen
if source=="L":
source="#" # Trigger zuruecksetzen
bucketHour += cLinks # aufsummieren
print("Links", bucketHour,"+",h,":",m,":",s)
elif source=="R":
source="-" # Trigger zuruecksetzen
bucketHour += cRechts # aufsummieren
print("rechts",bucketHour,"-",h,":",m,":",s)
datum=f"{D:02}.{M:02}.{Y}" # Datums- und Zeit-String bauen
zeit=f"{h:02}:{m:02}:{s:02}"
niederschlag="\'\'\'\' {:.2f} mm". /
format(bucketHour/area*10) # dto. Niederschlag in mm
d.clearAll(False) # Display loeschen
d.writeAt(datum,3,0,False)
d.writeAt(zeit,4,1,False)
d.writeAt(niederschlag,3,3)
if jetztBlinken(): # Wenn Timer abgelaufen, kurz blitzen
jetztBlinken=TimeOutMs(2000) # Ablauf neu setzen
led(1) # LED an
sleep_ms(5)
led(0) # und wieder aus
if key()==0: # Falls Taste key gedrueckt,
sys.exit(shutdown()) # shutdown() aufrufen und Ende
Om tekst gemengd met cijfers uit te voeren, kunt u op voordelige wijze formatstrings gebruiken. Er zijn twee varianten, f-reeks en de functie formaat(). De citaten zijn vergelijkbaar.
>>> D,M,Y = 14,6,2024
>>> f"{D:02}.{M:02}.{Y}"
'14.06.2024'
Dit zet de dag en de maand in twee cijfers en het jaar in een string, gescheiden door punten.
>>> "{:02}.{:02}.{}".format(D,M,Y)
'14.06.2024'
Dit formulier levert hetzelfde resultaat op. De eerste variant is ideaal voor de structuur van HTML-teksten. Bij de tweede variant kan de regel worden onderbroken met "\" als deze te lang wordt, zoals in de bovenstaande lijst. De formaatinstructies zijn zeer divers. Als je ze allemaal zou opsommen, zou je verschillende blogafleveringen kunnen vullen.
Een woord over de display-uitgangen. Wijzigingen voor het display worden eerst naar een buffergeheugen in RAM geschreven, dat ook direct naar het display wordt gestuurd als u zich in de schrijfAT()- of helderAlles() geef het argument weer Vals weglaat of via a WAAR vervangen. Maar het scherm flikkert dan en dat is vervelend. Daarom laat ik de nieuwe bufferinhoud eerst volledig in het RAM opbouwen en pas met het laatste schrijfcommando de volledige inhoud overbrengen. Dat haalt de hectiek uit het geheel.
Start nu het programma en beweeg de wip. De linker- of rechteruitvoer kan meerdere keren achter elkaar verschijnen, zelfs als er slechts één kantelbeweging is uitgevoerd. Dit fenomeen had ik ook bij mijn rechter reedcontact: contact stuiterde bij het sluiten. Hoe dit programmatisch kan worden geëlimineerd en verdere toevoegingen aan het project zullen in de volgende aflevering worden gegeven.
Tot die tijd – blijf op de hoogte!
1 Reactie
Francesco Cerquone
Salve. Mi chiedevo se per misurare in modo semplice la quantità di acqua caduta dal cielo non è meglio misurare il suo peso, anzichè il suo volume?
Per esempio un estensimetro o cella di carico come sensore del peso dell’acqua….