| ergens
in
december 2024 Python Een beetje tegen heug en meug ben ik erin gerold. Voor wie het niet weet, Python is een programmeertaal. Mijn project om het vullen van mijn pelletketel te automatiseren had me geleerd dat ik er best een aantal veiligheden zou inbouwen, maar die veiligheden bestonden dan feitelijk enkel uit extra timers. Nu dat alles relais-gestuurd is zit er slechts één timer in verwerkt en de rest draait zo goed als onbeveiligd. Het komt er dus op neer dat een aantal handelingen binnen een bepaalde tijdspanne moeten afgehandeld zijn en daarvoor gebruik je timers. De bedrading van mijn relais sturing is al tamelijk gecompliceerd geworden en extra timers, waarvoor trouwens geen plaats meer is in de stuurkast, zouden de zaken qua bedrading nogal fors moeilijker maken. Momenteel werkt die relaissturing vrij goed, maar ik moet er altijd bij zijn voor het geval er toch iets misloopt. Vervelend want dat belet dat ik in de winter voor langere tijd van huis weg kan gaan. De pelletvoorraad in de ketel moet, zeker als het wat kouder is, zowat dagelijks worden bijgevuld. Er drong zich dus een andere oplossing op en die vond ik in de vorm van een PLC. PLC staat voor "Programmable Logic Controller". Dat is dus een computer(tje) die alles aanstuurt maar die je voor dat doel speciaal dient te programmeren. Ik vond een geschikte en, vooral, betaalbare PLC in de vorm van een Raspberry Pi4. Dat het dingetje draait op Linux als besturingssysteem maakte het voor mij alleen maar mooier. En nog mooier omdat het, net zoals Ubuntu, een Debian versie was en de leercurve dus vrij kort was. Alleen, de programmeertaal die men voorstelde was Python en ik had tot dan nog nooit iets geprogrammeerd in Python. Effe een nieuwe programmeertaal aanleren dus. Al snel stelde ik vast dat dit een 'moderne' taal was en dat er dus bepaalde beperkingen aan zaten waar ik in de programmeertalen in mijn jonge jaren niet mee moest kampen. De voornaamse beperking van Python is dat het een lineaire taal is, dus het programma start aan het begin en loopt onverstoord verder tot aan het einde en dan is het gedaan. Er bestaat in Python namelijk geen "GOTO" instructie. Je kan je programma dus niet met een eenvoudige instructie vanaf een bepaald punt in het programma naar een ander punt laten springen. Nee, het programma loopt gewoon verder naar beneden. Waarom men tegenwoordig zowat alle programmeertalen op deze manier ontwikkelt laat ik even buiten beschouwing nu. Ik vind persoonlijk dat de reden hierachter nonsens is, maar alles veel onoverzichtelijker en onnodig complex maakt. Je dient wel, altijd en ten alle tijde, een flowchart te maken van datgene wat je wil programmeren. Altijd. Zonder uitzondering, onder het motto "Weet waarmee je bezig bent.". In het kort, de met ster voornaamste instructie in Python is de "while" instructie. Komt erop neer dat je alles wat na de "while" komt gaat uitvoeren zolang de voorwaarde die je bij de "while" schrijft waar is. En dan, na de "while" instructie gebruik je meerdere andere "while" instructies of "if ... then ... else ..." instructies. Met enkel die twee instructies kom je al een heel eind verder, dus zo moeilijk is dat nu ook weer niet. Alleen moet je weten dat je in Python de "then" niet moet schrijven. Die wordt sowieso verondersteld om altijd te volgen op de "if". Voort kan je kiezen uit een hele resem voorgeprogrammeerde modules die elk een aantal functies bevatten. Je kan dit zien als een bibliotheek met heel wat boeken en elk hoofdstuk in ieder boek gaat over iets anders. Die hoofdstukken zijn dan de functies. Dit is een systeem dat in moderne programmeertalen heel gebruikelijk is. C++ bv staat er bol van. Je moet die instructies dus niet zelf meer uitvinden, je kan ze gewoon lenen uit de bibliotheek. Wat moet je nog weten? Dat is dat de hiërarchie van het programma gekoppeld is aan de "indents" die je er zelf in zet. Klinkt moeilijker dan het is, maar het houdt steek. Wanneer je het programma start dan gebeurt de uitvoering ervan altijd op de eerste regel en zo werk je verder naar beneden. Eerste probleem is dat je bij aanvang van het programma vaak dingen zet die het programma slechts één keer dient uit te voeren, dus het is overbodig en wellicht ook gevaarlijk als je dat stuk code telkens weer opnieuw zou uitvoeren. Tijd voor een praktisch voorbeeld en we beginnen gelijk met een timer. import time
from time import sleep start = time.time() end = time.time() while (end - start) < 3: end = time.time() print (end - start) sleep(1) Om te beginnen roep je uit de module "time" op. Dat is dan de programmalijn "import time". De module "time" bevat een aantal functies die je kan oproepen. De functie "time.time()" dien je niet apart te importeren, de functie "sleep()" wel. Dan benoem ik enkele variabelen: "start" en "end" en vul er gelijk ook een waarde in. Daarmee weet Pyhton 1) dat het variabelen zijn en 2) dat ze numerisch zijn en 3) dat het in dit geval "floating point" variabelen zijn. Als je niet weet wat ik bedoel met "variabelen" en "floating point" dan heb je nog enig opzoekingswerk voor de boeg want ik ga daar hier niet verder op ingaan. Om te weten wat je allemaal kan doen met de opgeroepen functies dien je jezelf daaromtrent te documenteren. In een Python omgeving kan dat met de "help" instructie. Bijvoorbeeld "help('time')". Dan krijg je voor de functie "sleep" dit te zien: sleep(...)
sleep(seconds) In het voorbeeld hierboven laat ik het programma dus telkens 1 seconde wachten na de "print" instructie. Wanneer je in je programma veel code (programmeerinstructies) hebt staan kan het nogal wat zoekwerk betekenen wanneer je telkens in al die code nu net die ene "sleep" instructie moet opzoeken om net daar het aantal seconden te wijzigen. Het mooie aan Pyhton is dat je daar net zo goed een variabele kan invullen en die variabele kan je in het begin van je programma een waarde meegeven. Of je zou die ook ergens in het programma van waarde kunnen veranderen als daar behoefte aan is. Op die manier kan je wel erg flexibel werken. import time
from time import sleep T1 = 1.5 start = time.time() end = time.time() while (end - start) < 3: end = time.time() print (end - start) sleep(T1) Ik heb nu voor T 1.5 seconden genomen, maar je kan daar in feite elk willekeurig getal dat nog steekhoudt invullen. Je zou de waarde van T1 ook kunnen laten bepalen door een berekening en dan wordt het echt leuk en worden de mogelijkheden zo goed als onbegrensd en dan kan het er bv zo uitzien: import time
from time import sleep a = 0.5 b = 2.25 T1 = a * b start = time.time() end = time.time() while (end - start) < 3: end = time.time() print (end - start) sleep(T1) In bovenstaand voorbeeld wordt T1 gelijk aan 1.125 seconden. We hebben nu binnen een timer een tijdspanne gedefinieerd waarna de verstreken tijd wordt afgedrukt. Vanzelfsprekend kan ook de "3" in de "while" instructie door een variabele vervangen worden, welk dan weer op zijn beurt afhankelijk zou kunnen zijn van een berekening zoals hieronder, waarbij ik even voor het gemak ook de waarde van T1 en T2 afdruk: import time
from time import sleep a = 0.5 b = 2.25 T1 = a * b print('T1 = ',T1) T2 = b / a print('T2 = ',T2) start = time.time() end = time.time() while (end - start) < T2: end = time.time() print (end - start) sleep(T1) Wat doet dit programmaatje nu precies? Wel, zie de uitdraai hieronder: T1 = 1.125
T2 = 4.5 9.5367431640625e-07 1.1263527870178223 2.25321888923645 3.379896640777588 4.50659704208374 Er wordt om de 1.125 seconden de waarde van de verlopen tijd afgedrukt. Na 4.5 seconden stopt het ding vanzelf. Je merkt meteen ook al dat de functie "time.time" vrij ver na het decimaal gaat. Of dat enig praktisch nut heeft is dan weer een andere zaak want wanneer je dat programma meerdere keren laat lopen zal je telkens net iets andere waardes te zien krijgen. Hiermee wil ik het verhaal over timers afsluiten. Er valt natuurlijk veel meer over te zeggen, maar daar zoek je zelf maar op. Een oplossing vinden voor een timer probleem is volgens mij zo goed als altijd mogelijk in Python, zolang je maar beseft dat je best geen tijdmeting doet die rekent op waardes van kleiner dan 1/100ste van een seconde. De volgende stap is een equivalent vinden voor een "goto" instructie. Als je weet hoe, dan is dat kinderspel, maar weet wel dat de "goto" instructie op zich niet bestaat in Python. Je zal enige vindingrijkheid aan de dag moeten leggen en dat kan je dan zien in deel 2. OVERZICHT VOLGENDE |