Hoe heet deze manier van programma afloop? (uC AVR)

Ik zou het persoonlijk een 'time based scheduler' noemen, ook al wordt in dit voorbeeld maar 1 taak aangeroepen. Soortgelijke constructies zie je in bijna elk (RT)OS in de vorm van een bijvoorbeeld een SysTick welke de kernel tijd geeft om zijn ding te doen.

Eerste hit op google met 'arduino' erbij wordt dan deze

[Bericht gewijzigd door Anoniem op maandag 12 augustus 2019 16:27:34 (41%)

Dat noemt men, het woord zegt het zelf, cyclustijd (cycletime).
Dat is een heel prettige programmeeromgeving om hardware mee aan te sturen of in te lezen.
Je weet dat om de zoveel tijd het volledige programma wordt doorlopen, het loopt met andere woorden nooit vast.

Als je eens wilt proberen kun je LDmicro downloaden, de laatste versie staat hier
Er is geen installatie vereist, enkel de exe file starten.
Enige uitleg kun je hier vinden.

Het is mijn favoriete programmeeromgeving maar het heeft veel beperkingen als je wilt communiceren met andere apparatuur, enkel UART is goed ontwikkeld wat meestal voldoet.

En de simulator is het neusje van de zalm, je weet bijna altijd op voorhand of het gaat werken of niet, maar je moet wel oefenen zoals met alles.

Alles wat je hier ziet is gemaakt met LDmicro, uitgenomen dat mousewheel-dinges en ik heb nog zeer veel andere programma's en routines gemaakt.

Op 12 augustus 2019 16:02:00 schreef drieske:
Hoe heet deze manier van programma aansturing?

Dom?
_{Sorry, kon het niet laten.}

Wat ik slecht vindt aan deze methode is dat je heel veel processortijd kwijt bent met al dat wachten. In de tussentijd had je best nog wat tijd-onkritische dingen kunnen doen, bv het scannen van je toetsen, of het getal PI uitrekenen Je kunt in die interrupt bv een vlaggetje zetten. In je main loop kijk je dan (voor de kritische zaken) naar die vlag zodat je weet dat daar weer wat moet gebeuren.
Een andere manier is om een teller op te hogen in de interrupt. Elk proces kan dan zien hoeveel tijd er verstreken is.

Op 12 augustus 2019 16:53:15 schreef flipflop:
Wat ik slecht vindt aan deze methode is dat je heel veel processortijd kwijt bent met al dat wachten.

Wat boeit dat? Als TS de tijd heeft geeft dat niks. Een cyclische programma afloop op deze manier is niet ongebruikelijk.

Tussen de cyclus door zou er in de wachttijd nog een cyclus kunnen lopen, zodat er dus schijnbaar meerdere taken parallel lopen. En in de resterende tijd kun je ook nog een vrij lopende taak zetten. Allemaal reuze gebruikelijk.

Dit "dom" noemen doet vermoeden dat je in ieder geval nooit iets in de besturingstechniek hebt gedaan.

Nog beter is het natuurlijk om de processor in een of andere vorm van 'slaap' te zetten. De timer genereert een interrupt die het ding weer wakker maakt en het programma een keer laat lopen. Scheelt vaak heel veel in het energieverbruik.
Overigens is het ook bij deze methode nog steeds heel goed mogelijk dat je programmaatje vastloopt. Zet elke keer maar eens iets op de stack en vergeet het eraf te halen. Of: denken dat je je array nog wel wat verder kunt oprekken, verder dan het geheugen groot is.

Op 12 augustus 2019 16:53:15 schreef flipflop:
[...]
Dom?
_{Sorry, kon het niet laten.}

Het is uw volste recht maar volledig naast de kwestie, zoals zoveel antwoorden die zullen volgen _{(kon het ook niet laten)}

In de tussentijd had je best nog wat tijd-onkritische dingen kunnen doen, bv het scannen van je toetsen

Dat kan juist ideaal iedere 10mS in die loop...

Op 12 augustus 2019 16:25:25 schreef Pimmetje:
Ik zou het persoonlijk een 'time based scheduler' noemen...

...google met 'arduino' erbij...

Heel mooi dit zocht ik.

Op 12 augustus 2019 16:53:15 schreef flipflop:
[...]
Dom?
_{Sorry, kon het niet laten.}

Het is ook niet waar. Het is zeker niet dom. Maar wel erg afhankelijk van je toepassing en de omgeving waar het in draait. Of het z'n plek heeft in een Arduino...? Ik weet het niet. Maar voor de hobby mag alles, toch? En het is leerzaam, maar dan zou ik het gewoon zelf vanaf scratch implementeren.

In strakke real-time toepassingen is het een heel erg gebruikelijke manier van werken. Een kleine nuance: meestal wordt er in de main-loop wel op een timer gewacht, maar is dat dan hetzij de interrupt-vlag die wordt gelezen, hetzij een volledige counter waarde. Een echte interrupt wordt niet afgevuurd*.

In toepassingen die om deze methode vragen kost het je ook niet veel tijd, als je bedenkt dat je dusdanig deterministisch bezig bent dat je, als je programmatuur "af is" gewoon kunt uitrekenen hoe lang je main-loop worst-case zal duren. Als dat 9ms is, dan kun je aan het eind van elke loop wachten tot (ik zeg maar wat) 9,5ms en dan weer doorgaan. Je hebt nog een extra fail-safe: als je de timer ooit op 10ms betrapt, dan weet je zeker dat er iets fout is gegaan (althans: niet zoals jij had bedacht toen je de software schreef). Dat geeft je een watchdog, en afhankelijk van je toepassing kun je in een noodprogramma gaan, of resetten, of een error-lijn hoog maken, etc.
(* Deze watchdog wordt dan juist wél weer vaak als interrupt geïmplementeerd.)

Wij hebben deze methode meer dan eens in luchtvaarttoepassingen gebruikt.

Arduino heeft een millis() funktie die het aantal verstreken milliseconden geeft. Die kun je dan in de loop() gebruiken om uit te rekenen hoeveel tijd er verstreken is. Dan heb je geen interrupt meer nodig.

Jongens, reageer nou toch niet zo op het woord "dom". Er staat toch een achter!

Verder akkoord dat het volledig afhangt van de applicatie. Open deur.

Op 12 augustus 2019 18:30:13 schreef deKees:
Arduino heeft een millis() funktie die het aantal verstreken milliseconden geeft. Die kun je dan in de loop() gebruiken om uit te rekenen hoeveel tijd er verstreken is. Dan heb je geen interrupt meer nodig.

Ja... dit ga ik ook even bekijken. Voor lang draaiende applicaties Wel even de overflow na 50 dagen in de gaten houden.

[edit] Iedereen hartelijk bedankt voor het meedenken.