Eerst dit probleem
Met
timerinit()
kun je in AutoIt bijhouden hoe lang iets al loopt. Dat is handig als je script wacht op iets dat misschien nooit komt. Zonder tijdslimiet kan je script blijven hangen.
Dat is precies het punt hier: je wilt wachten, maar niet eindeloos. Je zet dus een timer aan, kijkt steeds hoeveel tijd er voorbij is met TimerDiff(), en stopt met ExitLoop als de wacht tijd te lang wordt.
Kort probleem
Stel je voor: je script stuurt een toets met
send()
of wacht op een reactie van een programma.Soms komt die reactie snel. Soms helemaal niet. Dan blijft je script doorzoeken of wachten, en dat is niet fijn.
Een timeout is dan de vanglijn. Timeout betekent: een maximale wachttijd. Komt er binnen die tijd niets, dan stopt je script netjes. Zo voorkom je dat een script vastloopt of uren blijft draaien.
De kern van de oplossing
De bron draait om drie dingen:
TimerInitzet het startmoment neerTimerDiffzegt hoeveel milliseconden er voorbij zijnExitLoopbreekt de lus af als de tijd op is
Dat is een simpele en sterke aanpak. Je start de timer vlak voor het wachten. Daarna check je in de lus steeds of je nog onder de grens zit. is de grens voorbij, dan stop je.
Waarom timeouts belangrijk zijn
Timeouts zijn belangrijk omdat wachtwerk niet altijd goed gaat. Een venster kan anders reageren, een knop kan niet verschijnen, of een toetsenactie komt niet aan.Zonder timeout blijft je script hangen. Met timeout blijft je script rustig en netjes stoppen.
Dat geeft drie voordelen:
- je script blijft niet vastzitten
- je weet beter waar het misgaat
- je kunt later een foutmelding of herstelstap zetten
Stap voor stap
Eerst start je de timer met
TimerInit()
. Dat doe je op het moment dat je begint met wachten. Daarna zet je een limiet, bijvoorbeeld 5000 milliseconden. Dat is 5 seconden.
Dan kom je in een lus. In die lus kijk je of je doel al bereikt is. Denk aan: is het venster klaar, is de toets verwerkt, of is de gewenste tekst verschenen? Als dat niet zo is, kijk je naar de timer.
Als TimerDiff($hTimer) groter wordt dan je grens, stop je de lus met exitloop. Zo houd je de wachttijd in de hand.
Voorbeeldcode
Local $hTimer = TimerInit()
Local $iTimeout = 5000 ; 5 seconden
While 1
; Hier kun je iets controleren,bijvoorbeeld:
; is het venster al klaar? Is de reactie er al?
; Als het doel bereikt is,breek je normaal ook af.
If TimerDiff($hTimer) > $iTimeout Then
ExitLoop
EndIf
sleep(50)
WEndDeze code laat het basisidee zien. De lus blijft niet eindeloos lopen. Elke ronde kijkt hij of de tijd voorbij is. De
Sleep(50)
zorgt ervoor dat het script niet onnodig hard blijft draaien.
Zo lees je de code
Local $hTimer = TimerInit()
hier begint de meting.De naam
hTimer
is een variabele.Die bewaart een startpunt van de timer.
Local $iTimeout = 5000
Hier zet je de grens. De tijd is in milliseconden. 5000 milliseconden is 5 seconden.
If TimerDiff($hTimer) > $iTimeout Then
Hier vraag je: is de verstreken tijd groter dan de grens? Zo ja, dan is het wachten te lang geworden.
ExitLoop
Hier stop je de lus. Dat is de nette manier om uit een While-lus te gaan.
sleep(50)
Hier laat je het script even pauzeren. Dat is beter dan razendsnel blijven checken. Zo gebruik je minder CPU.
Waar past dit bij Send()?
De bron noemt ook het automatisch sturen van toetsen met
Send()
. Dat lijkt simpel, maar soms moet je na het sturen nog even wachten op een reactie. Bijvoorbeeld op een venster,een tekstveld of een proces dat nog bezig is.
Dan kun je de timer gebruiken om dat wachten te begrenzen. Je stuurt de toets, en daarna wacht je in een lus tot het doel er is. als het doel na een tijdje nog niet zichtbaar is, stop je. Zo maak je je script veel veiliger.
een klein voorbeeld van dat idee:
Send("{ENTER}")
Local $hTimer = TimerInit()
Local $iTimeout = 3000
While 1
; Controleer hier of de gewenste reactie er is.
If TimerDiff($hTimer) > $iTimeout Then
ExitLoop
EndIf
Sleep(50)
WEndDit is geen complete oplossing voor elk script, maar wel het basispatroon. Eerst actie,daarna wachten met een grens. Lekker helder 🦫
Kleine test
Je kunt dit soort timeout goed testen door expres iets niet te laten gebeuren. Bijvoorbeeld een venster dat je verwacht, maar dat je niet opent. Als je script dan netjes stopt na de timeout,weet je dat de basis klopt.
Let wel op: test niet alleen de snelle weg. Test ook de mislukte weg. Juist daar zie je of je script goed blijft werken als iets fout gaat.
Veelgemaakte fout
Een veelgemaakte fout is dat mensen wel een lus maken, maar geen tijdslimiet zetten.Dan blijft de lus doen wat hij doet, ook als het doel nooit komt. Dat is precies het probleem dat je hier wilt voorkomen.
Een tweede fout is dat de timer te laat start. Start hem direct als je begint met wachten.Niet pas veel later. Anders meet je niet de echte wachttijd.
Nog een punt: gebruik geen te grote check-sprongen. Als je maar eens per paar seconden kijkt, reageert je script traag. Met een korte Sleep() en een timer krijg je een betere balans.
Handige punten om te onthouden
| Onderdeel | Wat doet het? | Waarom handig? |
|---|---|---|
TimerInit() | Zet het startmoment | Je weet wanneer het wachten begon |
TimerDiff() | Meet verstreken tijd | Je kunt een timeout maken |
ExitLoop | Stopt de lus | Je voorkomt eindeloos wachten |
De tijden zijn in milliseconden. Dus 1000 is 1 seconde.Dat is handig om te onthouden als je zelf een grens kiest.
Documentatie
Voor de bron of extra uitleg kun je ook terecht op Timeouts maken met TimerInit en TimerDiff in AutoIt.
Bevers gedachte
Een script dat kan wachten, moet ook kunnen stoppen. Dat maakt je code vriendelijker voor jezelf. je hoeft later niet te raden waarom iets vastliep.
De combinatie van TimerInit(), TimerDiff() en ExitLoop is simpel, maar heel nuttig. Je houdt de controle. En dat is vaak precies wat je wilt in AutoIt: niet blind wachten, maar netjes afkappen als het te lang duurt.
Als je dit patroon onthoudt, kun je er veel mee doen.Met Send(), met vensters, met knoppen, of met elke stap waar iets kan uitblijven. Klein stuk gereedschap, groot verschil.