loopt vast met arduino programmering

hallo alle,

ben bezig met programmering van arduino.
alleen loop daar vast mee.

mij vaatwasser computer is kapot gegaan. en wil hem proberen te vervangen door een adruino (een leuk projectje toch)

heb nu 2 druk knoppen voor 2 verschillende was programma, een korte en lange.

4 relais om alles te bedienen.

de bedoeling is als ik bijvoorbeeld knop kort in drukt. dan moet hij het programma afspelen met delay. het zelfde gaat ook voor de lange programma.

maar ik loop vast met compile van het arduino code.
misschien dat jullie mij kunnen helpen waar het fout gaat.

alvast erg bedankt

help

Golden Member

Welke foutmelding(en) krijg je?
Hieronder je eigen code in een post, is beter leesbaar en niet iedereen wil een onbekend bestand downloaden.

c code:

ldingen const int BUTTON_PIN_K = 8;  
const int BUTTON_PIN_L = 7;
const int RELAY_PIN_1 = 9;
const int RELAY_PIN_2 = 10;
const int RELAY_PIN_3 = 11;
const int RELAY_PIN_4 = 12; 

int lastButtonState_K;    // the previous state of button
int currentButtonState_K; // the current state of button
int lastButtonState_L;    // the previous state of button
int currentButtonState_L; // the current state of button


void setup() {
  Serial.begin(9600);                  // initialize serial
  pinMode(BUTTON_PIN_K, INPUT_PULLUP); // set arduino pin to input pull-up mode
  pinMode(BUTTON_PIN_L, INPUT_PULLUP);
  pinMode(RELAY_PIN_1, OUTPUT);        // set arduino pin to output mode
  pinMode(RELAY_PIN_2, OUTPUT);
  pinMode(RELAY_PIN_3, OUTPUT);
  pinMode(RELAY_PIN_4, OUTPUT);  


  currentButtonState_K = digitalRead(BUTTON_PIN_K);
  currentButtonState_L = digitalRead(BUTTON_PIN_L);

  digitalWrite(RELAY_PIN_1, LOW);
  digitalWrite(RELAY_PIN_2, LOW);
  digitalWrite(RELAY_PIN_3, LOW);
  digitalWrite(RELAY_PIN_4, LOW);
  
}
  
void loop() {
  lastButtonState_k = currentButtonState_k ;     // save the last state
  currentButtonState_K = digitalRead(BUTTON_PIN_K); // read new state

  if(lastButtonState_K == HIGH && currentButtonState_K == LOW) {
    Serial.println("The button kort is pressed");
  
      digitalWrite(RELAY_PIN_4,HIGH);
      delay(500);
      digitalWrite(RELAY_PIN_4,LOW);
      digitalWrite(RELAY_PIN_2,HIGH);
      delay(120000);
      digitalWrite(RELAY_PIN_2,LOW);
      digitalWrite(RELAY_PIN_1,HIGH);
      delay(15000);
      digitalWrite(RELAY_PIN_1,LOW);

      // end of program kort
  }
  if(lastButtonState_L == HIGH && currentButtonState_L == LOW) {
    Serial.println("The button LANG is pressed");

          digitalWrite(RELAY_PIN_4,HIGH);
      delay(500);
      digitalWrite(RELAY_PIN_4,LOW);
      digitalWrite(RELAY_PIN_2,HIGH);
      delay(360000);
      digitalWrite(RELAY_PIN_2,LOW);
      digitalWrite(RELAY_PIN_1,HIGH);
      delay(15000);
      digitalWrite(RELAY_PIN_1,LOW);

      // end of program lang
  }
}

Paar dingen die ik me o.a. afvraag, hoe regel je de temperatuur?
En op deze manier programmeren met delay zorgt ervoor dat je hele programma 'vast' zit totdat de delay afgelopen is.
Beter maak je gebruik van bijvoorbeeld de millis functie
https://www.arduino.cc/reference/en/language/functions/time/millis/
https://docs.arduino.cc/built-in-examples/digital/BlinkWithoutDelay

@help: daar is best waarheid in uw reactie, maar de topicstarter zal er niet zoveel aan hebben vrees ik. Het is helemaal geen antwoord op het gestelde probleem.

Als we nu eerst eens mogen weten wat er mis gaat bij het compileren, dan kunnen we misschien gerichter helpen.

[edit: @Aart hieronder zou wel eens een goede tip kunnen hebben, alleen had ik geen zin om tot 35 te tellen ]

[Bericht gewijzigd door Paulinha_B op zaterdag 24 december 2022 18:45:17 (17%)

Behoudens de hoofdletter-kleine letter fout op regel 35 compileert het bij mij voor de 32U4 / Arduin Micro. Code verder niet gelezen.

de foutcode is:

Arduino:1.8.19 (Windows 10), Board:"Arduino Nano, ATmega328P (Old Bootloader)"

D:\Projecten\Vaatwasser\vaatwasser_3\vaatwasser_3.ino: In function 'void loop()':

vaatwasser_3:35:3: error: 'lastButtonState_k' was not declared in this scope

lastButtonState_k = currentButtonState_k ; // save the last state

^~~~~~~~~~~~~~~~~

D:\Projecten\Vaatwasser\vaatwasser_3\vaatwasser_3.ino:35:3: note: suggested alternative: 'lastButtonState_L'

lastButtonState_k = currentButtonState_k ; // save the last state

^~~~~~~~~~~~~~~~~

lastButtonState_L

vaatwasser_3:35:23: error: 'currentButtonState_k' was not declared in this scope

lastButtonState_k = currentButtonState_k ; // save the last state

^~~~~~~~~~~~~~~~~~~~

D:\Projecten\Vaatwasser\vaatwasser_3\vaatwasser_3.ino:35:23: note: suggested alternative: 'currentButtonState_L'

lastButtonState_k = currentButtonState_k ; // save the last state

^~~~~~~~~~~~~~~~~~~~

currentButtonState_L

exit status 1

'lastButtonState_k' was not declared in this scope

wat betreft over temp en andere regelingen. die zijn analog. hier zat een soort nokkenschakel klokje op. vandaar dat ik nu het zelfde doet met een delay. de tijden enzo moeten nog verfijnt worden.

Tsja, dan lijkt @Aart het helemaal goed begrepen te hebben. Kun je iets met die "suggested alternative"s? Mij lijken die echt wel de pap in de mond te lepelen...

Je hebt lastButtonState_k niet gedeclareerd. Wat heb ik gewonnen?

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

pfff, je hebt de prijs gewonnen voor het voorbijklappen. In plaats van het ontdekken aan de topicstarter zelve over te laten, er waren duidelijke aanwijzingen geboden.

benleentje

Golden Member

Op 24 december 2022 18:34:33 schreef Paulinha_B:
@help: daar is best waarheid in uw reactie, maar de topicstarter zal er niet zoveel aan hebben vrees ik.

Maar ik en de rest van degene die dit topic willen volgen hebben er zeker heel ergveel aan. BEankt @help dat je zo goed helpt. ;) Een antwoord hoeft dus niet alleen de TS te helpen maar kan in dit geval wel de rest van de gebruikers helpen.

dan moet hij het programma afspelen met delay. het zelfde gaat ook voor de lange programma.

Nee dat mot je eigenlijk nooit doen. Om vaak heel veer redenenen.

Een delay is een totaal programma blokkerde code. Metanere woorden de microcontroller kan gedurende de delau lus helemaal niets anders meer doen en ook niet dingen als

Reageren op een drukknop > Als je bv het programma zou willen stoppen dan kan dat niet meer.
Temperatuur regeling. Ook dit werk dan neit en je verwarmings element blijft gedurende de delay aanstaan.

Het leuke van loop() is dat die eindeloos herhaalt word, nu met al die delays gebeurt dat niet meer.

Je kan dan wel met interrupt op de ingang van bv je temperatuur interrups gebruiken.

Een betere manier is om delay totaal te vermijden en met millis() te gaan werken.
https://forum.arduino.cc/t/using-millis-for-timing-a-beginners-guide/4…

Millis() word op de chtergrond altijd gestart in een Arduino.
HEt is in weze gewoon een counter die telt hoeveel miliseconde er is verstreken vanaf dat de Arduino is aangezet. Na ongeveer 49 dagen begint de teller pas weer opnieuw.

Dus ipv van

c code:

delay(1000)

Doe je op dat moment de waarde van millis() opslaan in een variabele zoals

c code:

long long newDelayEndTime = millis() + 1000. 

En daarna

c code:

if (millis()=>newDelayEndTime ) {
 Hier je code
}

Maar heel simpel is het niet je moet eigenlijk bijna je gehele programma anders schrijven omdat je ook moet gaan bij houden en welke toestand de wasmachine is.

Iets minder ingrijpend is dan om de delay veel kleine te maken en dan met een teller bijhouden hoe vaak die kleine delay al is uitgevoerd. maar heel veel eenvoudiger is dat ook niet.

Mensen zijn soms net als een gelijkrichter, ze willen graag hun gelijk hebben.
benleentje

Golden Member

Ik zou bv het volgende aanpassen

c code:


const int BUTTON_PIN_K = 8;  
const int BUTTON_PIN_L = 7;
const int RELAY_PIN_1 = 9;
const int RELAY_PIN_2 = 10;
const int RELAY_PIN_3 = 11;
const int RELAY_PIN_4 = 12; 

naar

c code:


const int toetsKortProgramma = 8;  
const int toetsLangProgramma = 7;
const int heater= 9;
const int centrufugeren = 10;
const int motorLinks = 11;
const int motorRechts = 12; 

Waarbij ik maar wat gegokt hebt qua functies.

En in de loop() de lange delays eruit halen. Een delay tot max 2 a 3seconde kan soms nog wel en laat ik hier gewoon zitten

c code:

  if(lastButtonState_K == HIGH && currentButtonState_K == LOW) {
    Serial.println("The button kort is pressed");
  
      digitalWrite(RELAY_PIN_4,HIGH);
      delay(500);
      digitalWrite(RELAY_PIN_4,LOW);

      //digitalWrite(RELAY_PIN_2,HIGH);
      //delay(120000);
      hoofdWas(120000);  //Aanroepen van routine hoofdwas met een tijd van 120000 zo kan je in de het lange was programma dezelfde routine gebruiken.
      // en dan de rest van de loop

c code:

void hoofdWas(int programDuration){

  long endTime = millis() + programDuration;
  digitalWrite(RELAY_PIN_2,HIGH);
  while(millis<=endTime){  // deze lus word continu herhaalt totdat millis() op de eindTijd is gekomen.
  //doe hier de dingen zoals motor vooruit en achteruit
  //waterniveau controleren en eventueel water bijvullen
  //temperatuur controleren en eventueel bij verwarmen
  //Controleren op fouten bv er een lekkage en de sensor voor lekkage is ingeschakeld en dan met break uit de while lus springen of als er geen water niveau is na zeg 60 seconde enz
  //Eventueel kijken of de stopknop word ingedrukt, een while lus kan altijd afgebroken werd met break
  } // einde van de while lus
  digitalWrite(RELAY_PIN_2,LOW);
}

Dit is een klein opzetje van hoe ik het zou doen.
Ik zxou voor elke apart blok een eigen routine maken
Dus voor het vullen van het water een eigen routine. Maar ook zo maken dat het niet blokkerend werkt.

Al met al lijkt een wasmachine heel simpel maar is er een eigen programma voor schrijven voor jouw nu nog een brug te ver. Dit omdat er veel dingen tegelijk geburen zoals
Water innemen totdat de water niveau schakelaar is geactiveerd.
Verwarmen tot de ingestelde temperatuur.
Motor linksom of rechtsom
enz

Mensen zijn soms net als een gelijkrichter, ze willen graag hun gelijk hebben.
buckfast_beekeeper

Golden Member

Op 24 december 2022 19:58:06 schreef benleentje:
[...]
Een betere manier is om delay totaal te vermijden en met millis() te gaan werken.
[...]

En soms zitten er verborgen delay in veel gebruikte libraries. Ik denk dan bijvoorbeeld aan de DS18B20 librarie die je programma gedurende x ms laat wachten tot de temperatuurconversie is gebeurd. De tijd afhankelijk van je gekozen resolutie. Als het goed gedaan is kan je dan de delay uitschakelen maar niet altijd. Voor DS18B20

c code:

sensors.setWaitForConversion(false);

Je moet dan wel zelf de 'wachttijd' voor conversie in programmeren met een millis().

Van Lambiek wordt goede geuze gemaakt.
bprosman

Golden Member

Op 24 december 2022 18:15:22 schreef Jd6130r:
hallo alle,

ben bezig met programmering van arduino.
alleen loop daar vast mee.

mij vaatwasser computer is kapot gegaan. en wil hem proberen te vervangen door een adruino (een leuk projectje toch)

heb nu 2 druk knoppen voor 2 verschillende was programma, een korte en lange.

4 relais om alles te bedienen.

de bedoeling is als ik bijvoorbeeld knop kort in drukt. dan moet hij het programma afspelen met delay. het zelfde gaat ook voor de lange programma.

maar ik loop vast met compile van het arduino code.
misschien dat jullie mij kunnen helpen waar het fout gaat.

alvast erg bedankt

Heeft al eens iemand gedaan hier :
https://www.circuitsonline.net/forum/view/148219/1

De jongere generatie loopt veel te vaak zijn PIC achterna.
benleentje

Golden Member

En soms zitten er verborgen delay in veel gebruikte libraries.

JA dat verkeerd om te zeggen dat je alle dealys altijd en overal moet vermijden, een korte delay is meestal niet zo een probleem
Een delay van bv 100mS maakt het nog steeds mogelijk om op drukknoppen te reageren. En als gebruiker merk je die 100mS vertraging ook niet zo heel erg.

Maar als er een wachttijd van 1 secondes is dan word het bedienen van drukknoppen wel heel erg vervelend. Je zal dus tijdens het ontwikkelen en testen van je programma heel alert moeten zijn waar een delay wel werkt en waar niet en je het anders moet oplossen.


IK was in de veronderstelling dat het om wasmachine voor kleding ging, somige hiervoor geplaatste opmerkingen zoals motor linksom en motor rechtsom zijn dus fout.

Mensen zijn soms net als een gelijkrichter, ze willen graag hun gelijk hebben.
EricP

mét CE

Wat een onzin dat delays per definitie 'slecht' zijn.
Ja, die controller doet verder niks meer (nou ja, de interrupts lopen door). Dat is correct. Maar als-ie verder niks hoeft te doen, dan doet dat niemand pijn.
Als - zoals in deze - het ding alleen een programma hoeft af te draaien, dan... hoeft-ie verder niks te doen. Het wordt een ander paar mouwen als je ondertussen bijvoorbeeld temperatuur wilt regelen of er moet ook een 'stop' knop in de gaten gehouden worden. Maar vooralsnog zie ik daar niks van.

Overigens is dat ook gelijk het probleem met dat 'Arduino-taaltje'. Veel te ver van de hardware af. Als ik zelf iets van besturing maak, dan draait dat doorgaans volledig interrupt driven en in de main loop niks anders dan een sleep() - die weer wakker wordt op het moment dat er een interrupt voorbij komt.

Voor wat betreft het compileren: flipflop geeft je de oplossing. Die ga je waarschijnlijk niet begrijpen, dus ik geef je er nog een hint bij: C is case sensitive. Meestal is dat erg handig, maar als je het niet weet ff niet.

Als het goed gedaan is kan je dan de delay uitschakelen maar niet altijd.

Je kunt altijd zonder delays werken. Maar het vereist wat meer begrip en wat meer programmeerkunsten.
Hang het in een timer interrupt die bijvoorbeeld elke 10mS loopt. Moet je 1 seconde wachten? Nou, da's 100x zinloos geschopt worden. Counter die aftelt (nee, niet vanaf 100 :) ) en bij '0' doe je je kunstje.
Voor die DS1820 heb ik ook wel eens zoiets gebakken. Leest elke seconde de temperatuur uit. 'Lezen' bestaat uit een variabele kopiëren en vervolgens de volgende conversie starten - die op een timer interrupt staat te bit-bangen. Als je kunt garanderen dat je slechts 1x per seconde leest, dan is-ie klaar voor je de volgende keer 'leest'. En uiteraard controleer je dat ff. Ja, je loopt een seconde achter met meten. Meestal is dat volkomen irrelevant.
Eea. gaat natuurlijk volkomen de mist in als je elke 10 minuten een temperatuur wilt hebben - dan krijg je de 'read' van 10 minuten terug. Echter, als het interval zo groot is, dan is een 'delay' hoogste waarschijnlijk ook geen probleem.

Het leuke van loop() is dat die eindeloos herhaalt word, nu met al die delays gebeurt dat niet meer.

Nog steeds hoor. Het duurt alleen wat langer :)

[Bericht gewijzigd door EricP op zondag 25 december 2022 08:06:55 (18%)

buckfast_beekeeper

Golden Member

Op 24 december 2022 23:44:55 schreef benleentje:
[...]

Maar als er een wachttijd van 1 secondes is dan word het bedienen van drukknoppen wel heel erg vervelend. Je zal dus tijdens het ontwikkelen en testen van je programma heel alert moeten zijn waar een delay wel werkt en waar niet en je het anders moet oplossen.

[...]

DS18B20 is bij 12bit resolutie 750ms. Problematisch als je controller elke halve seconde een led laat knipperen en de tijd op een display zet. Bij een schuivende regenboog met WS2812B zag je duidelijk het blokkeren gedurende het opvragen van de temperatuur. Die drukknop kan je ook nog aan een interrupt koppelen om dat euvel op te lossen.

Op 25 december 2022 07:55:43 schreef EricP:
Wat een onzin dat delays per definitie 'slecht' zijn.
Ja, die controller doet verder niks meer (nou ja, de interrupts lopen door). Dat is correct. Maar als-ie verder niks hoeft te doen, dan doet dat niemand pijn.
[...]

Eea. gaat natuurlijk volkomen de mist in als je elke 10 minuten een temperatuur wilt hebben - dan krijg je de 'read' van 10 minuten terug. Echter, als het interval zo groot is, dan is een 'delay' hoogste waarschijnlijk ook geen probleem.[...]

Daar zit net het grootste probleem. Velen hebben niet eens door dat hun programma wordt opgehouden door een lange delay. Komen ze klagen dat functie x of y soms wel werkt en soms niet. Delay heeft een functie. Anders was het al lang op de schop gegaan.

Of die 10 minuten een probleem is, hangt volledig samen met het gebruik. Hoe snel en hoe groot is de temperatuurvariatie? Wat doe je er mee?

Van Lambiek wordt goede geuze gemaakt.
EricP

mét CE

Velen hebben niet eens door dat hun programma wordt opgehouden door een lange delay.

Hun programma wordt niet opgehouden. Het doet precies wat de instructie beoogt: niks...

DS18B20 is bij 12bit resolutie 750ms. Problematisch als je controller elke halve seconde een led laat knipperen en de tijd op een display zet.

Niet als je het charmant oplost... Die LED laat je dus in een ISR doen. En die tijd ook. Dan kun je in je main prima een delay gebruiken. Of je doet de temperatuur uiteraard ook interrupt-driven...

Ohja... Ik bedenk net... Ik heb wel eens zoiets gebouwd. Een 4-digit LED display. Multiplexed uiteraard. Dat draait volledig 'background' en het enige wat je moet doen om iets op het display te krijgen is de bitmap in een variabele zetten. Waarom een bitmap? Nou, dan kun je ook andere dingen dan alleen getallen erin douwen.
De 'main' doet een 4-tal DD18B20s. En daar was ik lui: allemaal met delays. Wel zo slim om ze alle 4 tegelijk een 'conversion' te laten doen (nou ja, je start ze wel na elkaar, er zit meer op die bus). Display heeft daar echt geen pijn aan. Draait meen ik op 100Hz ofzo...

[Bericht gewijzigd door EricP op zondag 25 december 2022 09:39:04 (36%)

Ergens tussen een Arduinese delay(10000) en het zelf in assembly schrijven van een compleet OS zit een gepaste oplossing voor dit soort functies.
Een relevante factor daarbij is wat er in de vingers of voor in het hoofd zit, zodat het zo vlot en in perceptie zo eenvoudig mogelijk opgelost is. Hoewel er goede gewoontes zijn zal dat voor iedereen anders zijn.

Met deze voorbehouden; voor eenvoudige microcontroller projecten net wat voorbij het triviale neig ik tegenwoordig zelf naar:

  • Een state machine als hoofdstructuur.
  • Non-blocking code.
  • Systeemtikken van 10 of 100 ms, niet in de laatste plaats omdat het dan eenvoudig is de load in de gaten te houden, wat goed is voor het begrip wat er gebeurd en/of nog bij kan.
  • Interrupts enkel voor hardware gerelateerde zaken, zoals (rotary encoder-) pulsen tellen, stap pulsen zenden, samples nemen, displays multiplexen etc.
    Interrupts nooit voor drukknoppen, dan zou men in hardware moeten ontdenderen wat onelegant voelt.
    Ik lees de knop gewoon regelmatig, iedere tik, in. Mensen zijn toch niet zo snel ;)

hallo,

zoals vele van jullie al zijde had ik een kleine letter k gebruikt inplaats van hoofdletter K.

de arduino hoeft geen temperatuur te regelen. er zat hier maar 4 schakelingen op. 1 voor waterklep, 1 voor pomp, 1 voor stroom van de tijdklok, 1 voor de zeep pomp. de rest word analoog geregeld en hoeft de arduino niks mee te doen. de arduino neemt alleen de taken over van de tijdklok die kapot is. dus in dit geval de 4 relais de verder gewoon het zelfde blijft.

ik heb de programma nu werkend en ziet er goed uit met de delay. alleen heb nu het probleem dit die constant herhaalt terwijl ik de knop meer 1 x ingedrukt hebt.

heb vermoeden dat de buttonstate nog steeds op high staat. hoe kan ik die in het einde van de programma veranderen naar low.

alvast bedankt

Achter de if van program lang zet je beide weer op low

ik hou van werken ..., ik kan er uren naar kijken

Op 25 december 2022 19:44:06 schreef fcapri:
Achter de if van program lang zet je beide weer op low

currentButtonState_k = LOW;

currentButtonState_L = low;

op deze manier?

Arco

Special Member

Druktoetsen detecteren doe je in een timerinterrupt, dan wordt er niets opgehouden, en ben je veel flexibeler...

Arco - "Simplicity is a prerequisite for reliability" - hard-, firm-, en software ontwikkeling: www.arcovox.com

"doe je"? Dat is 1 mogelijke manier, ja, maar niet de enige, en niet alleenzaligmakend.

.dubbel

[Bericht gewijzigd door fcapri op maandag 26 december 2022 16:56:10 (99%)

ik hou van werken ..., ik kan er uren naar kijken

Op 25 december 2022 20:04:39 schreef Jd6130r:
[...]

currentButtonState_k = LOW;

currentButtonState_L = low;

op deze manier?

zo krijg je weer een fout dat die eerste niet gedeclareerd is. hoofdletter K gebruiken.
maar idd, zo kan je het doen.

eigenlijk zou ik de loop helemaal anders maken en je programma in sub programma runnen. het enige verschil is die ene tijd 120000 vs 360000. geef die als variabele mee

code:


void loop() {
  lastButtonState_K = currentButtonState_K ;     // save the last state
  currentButtonState_K = digitalRead(BUTTON_PIN_K); // read new state

  if(lastButtonState_K == HIGH && currentButtonState_K == LOW) {
      Serial.println("The button KORT is pressed");
      program(120000);
      currentButtonState_K = LOW;
      
  }
  if(lastButtonState_L == HIGH && currentButtonState_L == LOW) {
      Serial.println("The button LANG is pressed");
      program(360000);
      currentButtonState_L = LOW;
  }
}

void program(int programtijd) {
      digitalWrite(RELAY_PIN_4,HIGH);
      delay(500);
      digitalWrite(RELAY_PIN_4,LOW);
      digitalWrite(RELAY_PIN_2,HIGH);
      delay(programtijd);
      digitalWrite(RELAY_PIN_2,LOW);
      digitalWrite(RELAY_PIN_1,HIGH);
      delay(15000);
      digitalWrite(RELAY_PIN_1,LOW);
}

trouwens, werkt dat programma wel??? ik zie dat je nergens die BUTTON_PIN_L inleest in de loop, dus dat lang programma kan nooit draaien.

om uit de loop te geraken kan je ergens een variabele gebruiken.
bv in algedraaid = 0;

moment dat je 1 programma gestart hebt, zet je die op 1.
en in de loop maak je een grote if die enkel werkt als algedraaid op 0 staat.
heb je dus 1 vaat gedraaid, moet je resetten om nog eens te draaien.

daarna maak je een display met een menu, 4 drukknoppen (omhoog, omlaag, reset en start).
kan je in het display selectie maken:
eco program
normal program
lang program
eco is dan dat de watertemperatuur lager is dan beide.

kwa veiligheid zou je ook moeten ingrijpen als je computer vastloopt. dus een timer ernaast die de machine na pakweg 3uur spanningsloos zet als je arduino zijn programma niet heeft afgewerkt. je kan dan een foutcode genereren.
BV Error1: runtime to long
Error2: temperatuur not reached
....

en in no time heb je zelf een ingewikkelde vaatwas gebouwd met alle functies van een nieuwe ;-).

tip, zorg dat je de usb connector toegankelijk hebt, zodat je 'firmware updates' kan uitvoeren van alle nieuwigheden die je bijmaakt.
want je zal updates maken.
het volgende dat je wil, is een countdown timer op je display dat de tijd weergeeft voordat het programma gedaan is. je zal enorm bijleren met dit projectje en met wat kleine euros kan je opties toevoegen tot een met (een display van 2€, en draaiknopje voor in je menu te scrollen, opties om zelf je temperatuur in te stellen (koud-40°-60°...), nog eens extra naspoelen voor glazen...)

ik hou van werken ..., ik kan er uren naar kijken
EricP

mét CE

"doe je"? Dat is 1 mogelijke manier, ja, maar niet de enige, en niet alleenzaligmakend.

Toch ga ik daarbij volkomen met Arco mee. Het maakt 'ondenderen' kinderlijk eenvoudig - en die interrupt loopt toch.