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

Hallo allemaal.
Voor mijn projecten gebruik ik Atmega en ATtiny controllers. Programmeertaal is C.
Één van de timer-interrupts gebruik ik als clockpuls (bv. elke 10 ms) om binnen de main() een programma-cyclus te starten. In een programma cyclus wordt de hele programma code 1 x doorlopen.
Wanneer de cyclus afgelopen is wordt er gewacht op een interrupt van de betreffende timer voordat de volgende cyclus gestart wordt.
Tijdvertragingen zijn veelvouden van de clockpuls, in dit geval veelvouden van 10 ms.
Hoe heet deze manier van programma aansturing?

Ik wil namelijk zoeken of er ook Arduino code is die bruikbaar is voor deze methode.

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 Pimmetje op 12 augustus 2019 16:27:34 (41%)]

Never argue with idiots, they drag you down their level and beat you with experience!

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.

LDmicro user.

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.

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein
GJ_

Moderator

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.

Don't Panic!

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);):)

LDmicro user.

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... ;)

Arco - "Simplicity is a prerequisite for reliability" - www.arcovox.com

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.

Jochem

Golden Member

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.

Heb geduld: alle dingen zijn moeilijk voordat ze gemakkelijk worden.

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.

"We cannot solve our problems with the same thinking we used when we created them" - Albert Einstein

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.