Vraag beginner photobooth

De weerstanden per led wist ik. Uitgaan van een 12v voeding moet er per segment 180ohm weerstand voor.
R=(12-8,6)÷0.02=170 word dus 180ohm

Het solderen op printplaat heb ik dus nog nooit gedaan. Maar dat moet me vast wel lukken.

De UDN2981 kan ik wel krijgen (1,60p/s). Die zou ik nodig hebben voor common cathode.
Voor de common anode kan ik voor een losse PNP gaan.
Heb ik voor beide type 7-seg een oplossing. Kan ik nu kiezen wat ik wil.

De ground van de 7-segment displays moet wel worden gekoppeld aan de ground van de Arduino? Tenminste dit zie ik veel op schema's voorbij komen in me zoektocht.

De weerstand is juist. Let wel op dat de punt een veel hogere weerstand nodig heeft! Deze heeft maar 2 ledjes. 20mA door de ledjes is prima, zeker als je multiplexed. Maar zonder multiplex kan 20mA erg fel zijn.

Ja, met de UDN2981 zou je ook makkelijk een common cathode aan kunnen sturen. Heb je nog gewone NPN/N-mso nodig voor de common als je multiplexed.

Aan het feit dat de UDN2981 veel complexer is en het tienvoudige van een ULN2803 kost zie je maar weer waarom de voorkeur vaak uit gaat naar common anode :slight_smile:

Solderen van een print is niet zo lastig. Zorgen dat je soldeer met flux hebt (en liefst met lood), netjes eerst de bout tegen de print en component, beetje soldeer erbij, soldeer weg, wachten tot het mooi gevloeid is en dan pas bout weg. Tig filmpjes over te vinden. Ow, en pro tip, probeer niet in de lucht te solderen maar hou je polsen op de tafel. En ik vind klei (60 cent ofzo bij de Action) ideaal om printplaten en componenten even mee vast te zetten tijdens solderen :slight_smile:

Op zich heeft het display geen GND. Maar als je de kathode zijde / ULN2803 bedoelt, ja, die moet aan de Arduino GND. Stroom kan alleen in een ciceltje lopen :wink: Maar goed, het is allemaal heel makkelijk als je een 12V voeding pakt. Daarmee kan je direct de Arduino voeden en de displays en eventuele toeters/bellen/ledstrips. Je zou alleen nog kunnen kijken wat je camera en flitser als voeding zouden willen hebben.

De punt ga ik niet gebruiken. Maar ik wist dat daar een andere waarde weerstand voor moet.

Ik bedoelde idd de kathode zijde van de leds.
Die aansluiten op de arduino gnd.
Bij het gebruik van 1 12v voeding voor de 7-seg en de arduino, moet die dan ook nog apart naar de - van de voeding of is dat niet nodig? (Zoals in het schema van een paar post terug)

Bedankt voor de soldeer tips :slight_smile:

Ik zou niet voor een 112V voeding gaan :stuck_out_tongue: 12V is prima. :wink:

V- sluit je aan op GND ja. Het zal uiteindelijk ergens heen moeten he :wink: GND is alleen een naam voor de referentie. Alle andere spanningen refereren aan GND (tenzij anders aangegeven). Je an immers alleen een spanning ergens over meten. (Je moet altijd beide draden van je multimeter aansluiten om te meten.)

Dus V- van je voeding wordt GND
V+ van je voeding wordt je 12V
12V gaat naar Arduino
GND gaat naar Arduino
12v gaat naar high side (pnp/N-mos/UDN2981) van je display
GND gaat naar low side van je display, direct aan kathode zonde multiplex of aan ULN2803 (of NPN/N-mos) wanneer je multiplext.

Multiplexen lijkt me nu de makkelijkste optie. Heb je 1x UDN2981 en 1x ULN2803 nodig. Kan je met 10 pinnen van de arduino 3 dispays (zonder punt) aansturen. Makkelijk te doen met de Nano.

Als je goedkope Nano wilt, zie hier, zou ik hem wel vast bestellen. Duurt meestal week of 2 dat je hem hebt (en als je pech hebt 6 weken...).

Type foutje van mij. Bedoelde natuurlijk 1x 12v voeding :slight_smile:

Ik ben bezig met de code te schrijven, nu ben ik al aan het zoeken geweest maar wil toch even zeker weten of dit werkt zoals ik ingedachte heb.
Het foto proces komt steeds weer terug, als ik dit in een eigen void zet en het aanroep op het punt waar ik het nodig heb.

ik heb hier onder de int en setup en een aantal void weg gelaten. (tekst was te lang)
Gaat dit werken of is hier een andere manier voor?
Deze manier had ik ergens op google gevonden.
De hele code heb ik ook nog bijgevoegd

void schrijf0();                                   // display 3 schrijft 0 
void schrijf1();                                   // display 3 schrijft 1   
void schrijf2();                                   // display 3 schrijft 2 
void schrijf3();                                   // display 3 schrijft 3 
void schrijf10();                                  // dispaly 1 & 2 schrijft 10
void fotoproces();                                 // Countdown en trigger camera 
void schrijfniks();                                // display 1 & 2 uit  

void setup() {
}


void loop() {

  if (digitalRead(Schakelaar1) == LOW) {          //Keuze schakelaar aantal foto's (1)
    schrijf1();                                   // display 3 geeft 1 aan
    schrijf10();                                  // Display 1 & 2 geeft 10 aan, het aantal af te tellen seconde.
    if (digitalRead(Drukknop) == LOW) {           // Start Drukknop
      digitalWrite(LedReady, LOW);                // Led Ready Uit
      digitalWrite(LedProg, HIGH);                // Led Progesse Aan
      delay(250);                                 // vertraging om naar achter te stappen
      fotoproces();                               // fotoproces
      schrijf0();                                 // display 3 geeft 0 aan
      schrijfniks();                              // Display 1 & 2 uit
      digitalWrite(LedProg, LOW);                 // Led Procces uit
      digitalWrite(LedFinish, HIGH);              // Led Finish aan
      delay(2500);                                // vertraging
      digitalWrite(LedFinish, LOW);               // Led Finish uit
      digitalWrite(LedReady, HIGH);               // Led Ready aan
    }
  }
  else if (digitalRead(Schakelaar2) == LOW) {     // Keuze schakelaar aantal foto's (2)
    schrijf2();                                   // Display 3 geeft aantal te maken foto's aan 2
    schrijf10();                                  // Display 1 & 2 geeft 10 aan, het aantal af te tellen seconde.
    if (digitalRead(Drukknop) == LOW) {           // Start Drukknop
      digitalWrite(LedReady, LOW);                // Led Ready Uit
      digitalWrite(LedProg, HIGH);                // Led Progesse Aan
      delay(500);                                 // vertraging om naar achter te stappen
      fotoproces();                               // fotoproces
      schrijf1();                                 // display 3 geeft 1 aan
      fotoproces();                               // fotoproces
      schrijf0();                                 // display 3 geeft 0 aan
      schrijfniks();                              // Display 1 & 2 uit
      digitalWrite(LedProg, LOW);                 // Led Procces uit
      digitalWrite(LedFinish, HIGH);              // Led Finish aan
      delay(2500);                                // 5 seconde vertraging
      digitalWrite(LedFinish, LOW);               // Led Finish uit
      digitalWrite(LedReady, HIGH);               // Led Ready aan
    }
  }
  else if (digitalRead(Schakelaar2) == HIGH) {    // Keuze schakelaar aantal foto's (3)
    schrijf3();                                   // Display 3 geeft aantal te maken foto's aan 3
    schrijf10();                                  // Display 1 & 2 geeft 10 aan, het aantal af te tellen seconde.
    if (digitalRead(Drukknop) == LOW) {           // Start Drukknop
      digitalWrite(LedReady, LOW);                // Led Ready Uit
      digitalWrite(LedProg, HIGH);                // Led Progesse Aan
      delay(250);                                 // vertraging om naar achter te stappen
      fotoproces();                               // fotoproces
      schrijf2();                                 // display 3 geeft 2 aan
      fotoproces();                               // fotoproces
      schrijf1();                                 // display 3 geeft 1 aan
      fotoproces();                               // fotoproces
      schrijf0();                                 // display 3 geeft 0 aan
      schrijfniks();                              // Display 1 & 2 uit
      digitalWrite(LedProg, LOW);                 // Led Procces uit
      digitalWrite(LedFinish, HIGH);              // Led Finish aan
      delay(2500);                                // vertraging
      digitalWrite(LedFinish, LOW);               // Led Finish uit
      digitalWrite(LedReady, HIGH);               // Led Ready aan
    }
  }
}


void schrijf0() {                                //aantal te maken foto's 0 dispaly 3
  digitalWrite(Display3sA, HIGH);
  digitalWrite(Display3sB, HIGH);
  digitalWrite(Display3sC, HIGH);
  digitalWrite(Display3sD, HIGH);
  digitalWrite(Display3sE, HIGH);
  digitalWrite(Display3sF, HIGH);
  digitalWrite(Display3sG, LOW);
}

sketch_feb18b.ino (16.9 KB)

slechte gewoontes kun je beter zsm afleren… het is geen void maar een functie. De void die ervoor staat geeft aan dat deze functie niets (void = leegte) terug. Je loopt de kans dat een ander afhaakt omdat ie geen idee heeft waar je het over hebt.

nee dat gaat echt niet goed

  1. je hebt functies met dezelfde naam (de bovenste definities weghalen.
  2. ipv schrijf0() is het beter om schrijf(0) te gebruiken, of zelfs schrijf (3,0)
    en dan in de schrijf functie met case te werken, dus
    void schrijf(int cijfer, int getal)
    switch getal
    case 0
    digitalWrite segments.......

hoe je denkt is trouwens prima, want je wilt gewoon dat doen wat je op dat moment wilt zien, dat is gewoon beginnersmethode, maar als ik je iets bij kan brengen dan doe ik dat graag.

Nico heeft inderdaad gelijk, het is een functie.

Maar dan inhoudelijk je code. Vind je ook niet dat de functies schrijf1(), schrijf2() enz nogal op elkaar lijken? Zou het niet veel handiger zijn als een een functie had waar je het getal wat je weer zou willen geven als argument meer zou geven? schrijf(2) bijvoorbeeld? Dit lijkt mij de code al te halveren. :wink:

En veel werk is al een keer voor je gedaan als je bijvoorbeeld de SevSeg library pakt.

En ik had het de vorige keer ook al aangegeven, waarom begin je de hele check met de check voor het aantal foto's? Je hebt nu eigenlijk 3 keer dezelfde code geschreven voor niets. Of draai de twee om, check eerst of je een foto zou willen maken en kijk dan hoeveel. Of, en dat lijk me het beste, probeer te denken in allemaal losse processen. Stukje pseudocode om dat weer te geven.

byte aantalFotos; //aantal foto's dat genomen moet worden
bool gestart = false;

void setup(){
  //zet alles op zoals het moet
}

void loop(){
  //controleer de schakelaars en slaat op hoeveel foto's er genomen meoten worden
  checkFotoAantal(); 
  
  //zolang we nog niet bezig zijn met het nemen van een foto
  if(!gestart){
    //controleer de schakelaars en slaat op hoeveel foto's er genomen meoten worden
    //Sla dat op in aantalFotos
    checkFotoAantal(); 
    
    //controleer of je moet beginnen met foto proces
    gestart = updateStartKnop();
  }
  
  //Okay, we willen foto's nemen, alten we dat doen
  if(gestart){
    fotoProcess();
  }
  
  //schrijf alles naar het display
  updateDisplay()
}

Ik ga hier wel een beetje uit van een non-blocking stuctuur. Dit houdt in dat geen enkele functie heel lang mag duren (de boel blokkeren). Een functie als delay() is hiermee uit den boze. Waarom? Delay() is stom :smiley: Tijdens een delay() kan je helemaal niets. Je kan geen lampje laten knipperen, je kan niet kijken naar knoppen je kan dus zelfs niet je programma afbreken als je dat zou willen. En waarom is dat hier belangrijk? Zoals ik zei lijkt mij het handig (weinig transistors en draden nodig) om je display te multiplexen. Dit betekend wel dat je het scherm dus meerdere malen (enkele 100en keren) 'per seconde je scherm wilt updaten. Bij gebruik van de SevSeg library is dat sevseg.refreshDisplay();. Doe je dat niet zal de boel blijven hangen op één display wat verlicht is. En kan je zeggen, dat multiplex ik toch niet? Wat ik al zei, het is meer een van de dingen die je niet kunt. Gewoon maar domweg wachten (en een seconde is een heeeeeeeeeeeeeele lange tijd voor een microcontroller die werkt op 16MHz) is gewoon geen slimme zet. Is alsof je een eitje gaat koken, je timer op 5 minuten zet en na 2 minuten wel zien dat de boel in de fik is gevlogen maar niets doen tot je timer is afgelopen....

En dan nog twee vragen die ik al eens eerder had aangeduid. Voor beide geldt dat je keuze niet fout is ofzo, maar gewoon dingen doen zonder reden is eigenlijk de slechtste methode :smiley: En waarschijnlijk heb je wel een reden maar voor onze gedachten zou je de reden willen uitleggen?

Allereerst lijk je niet van de wijs te brengen over hoe je het aantal foto's wilt instellen :smiley: Nu is er niets mis met een standen schakelaar natuurlijk maar hiermee beperk je jezelf wel tot 3 standen (1, 2 of 3 foto's). Dit terwjl je alles hebt om met een simpele drukknop het aantal foto's in te kunnen stellen tussen 1 en 9 (want dat past makkelijk op je scherm). Gebruikt maar één pin, is flexibeler, simpel drukknopje kan op de printplaat en is goedkoop, scheelt draden (draden zijn evil, zitten altijd in de weg en kosten altijd meer tijd om aan te sluiten dan je denkt) enz Maar goed, wat ik zei, standen schakelaar is ook niet fout maar vroeg me vooral af waarom jij dit verkiest.

En dan nog je status ledjes, wat vind jij hier de meerwaarde van? Zoals gezegd, ready snap ik nog wel (zeker als je dit de verlichting van de knop maakt) maar procces en finish? Het aftellen lijkt me voor de mensen een duidelijkere indicatie dat de boel gestart is. En finisch is toch gewoon hetzelfde als ready? Als je klaar bent met de foto's ben je ook klaar voor een nieuwe ronde. Weer, kan het mis hebben vandaar de vraag naar je redenatie.

nicoverduin:
slechte gewoontes kun je beter zsm afleren… het is geen void maar een functie. De void die ervoor staat geeft aan dat deze functie niets (void = leegte) terug. Je loopt de kans dat een ander afhaakt omdat ie geen idee heeft waar je het over hebt.

Krijg je als je net begint met Arduino en programmeren, dan noem je wel eens dingen die niet zo heten.
Dus bij deze een functie :slight_smile:

shooter:
nee dat gaat echt niet goed

  1. je hebt functies met dezelfde naam (de bovenste definities weghalen.
  2. ipv schrijf0() is het beter om schrijf(0) te gebruiken, of zelfs schrijf (3,0)
    en dan in de schrijf functie met case te werken, dus
    void schrijf(int cijfer, int getal)
    switch getal
    case 0
    digitalWrite segments…

hoe je denkt is trouwens prima, want je wilt gewoon dat doen wat je op dat moment wilt zien, dat is gewoon beginnersmethode, maar als ik je iets bij kan brengen dan doe ik dat graag.

  1. dankje die heb ik verwijderd.
  2. de switch case ga ik me in verdiepen.

septillion:
Nico heeft inderdaad gelijk, het is een functie.

Maar dan inhoudelijk je code. Vind je ook niet dat de functies schrijf1(), schrijf2() enz nogal op elkaar lijken? Zou het niet veel handiger zijn als een een functie had waar je het getal wat je weer zou willen geven als argument meer zou geven? schrijf(2) bijvoorbeeld? Dit lijkt mij de code al te halveren. :wink:

En veel werk is al een keer voor je gedaan als je bijvoorbeeld de SevSeg library pakt.

Die functies , schrijf0, schrijf1, schrijf2, schrijf3 en schrijf10 lijken idd op elkaar.
Maar ik snap liever een code die langer is, dan een korte code die ik niet snap en knip en plak.
Dus ik ga me inlezen op die libray en kijken of ik er wijs uit word.
Zoals bv deze code voor countdown. De eerste korte code telt ook af maar die begrijp ik niet, de code er onder wel.
Als ik meer ervaring heb, zal ik vast ooit denken waarom heb ik het toen ooit zo gedaan.

septillion:
En ik had het de vorige keer ook al aangegeven, waarom begin je de hele check met de check voor het aantal foto’s? Je hebt nu eigenlijk 3 keer dezelfde code geschreven voor niets. Of draai de twee om, check eerst of je een foto zou willen maken en kijk dan hoeveel. Of, en dat lijk me het beste, probeer te denken in allemaal losse processen. Stukje pseudocode om dat weer te geven.

byte aantalFotos; //aantal foto's dat genomen moet worden

bool gestart = false;

void setup(){
  //zet alles op zoals het moet
}

void loop(){
  //controleer de schakelaars en slaat op hoeveel foto’s er genomen meoten worden
  checkFotoAantal();
 
  //zolang we nog niet bezig zijn met het nemen van een foto
  if(!gestart){
    //controleer de schakelaars en slaat op hoeveel foto’s er genomen meoten worden
    //Sla dat op in aantalFotos
    checkFotoAantal();
   
    //controleer of je moet beginnen met foto proces
    gestart = updateStartKnop();
  }
 
  //Okay, we willen foto’s nemen, alten we dat doen
  if(gestart){
    fotoProcess();
  }
 
  //schrijf alles naar het display
  updateDisplay()
}




Ik ga hier wel een beetje uit van een non-blocking stuctuur. Dit houdt in dat geen enkele functie heel lang mag duren (de boel blokkeren). Een functie als delay() is hiermee uit den boze. Waarom? Delay() is stom :D Tijdens een delay() kan je helemaal niets. Je kan geen lampje laten knipperen, je kan niet kijken naar knoppen je kan dus zelfs niet je programma afbreken als je dat zou willen. En waarom is dat hier belangrijk? Zoals ik zei lijkt mij het handig (weinig transistors en draden nodig) om je display te multiplexen. Dit betekend wel dat je het scherm dus meerdere malen (enkele 100en keren) 'per seconde je scherm wilt updaten. Bij gebruik van de SevSeg library is dat sevseg.refreshDisplay();. Doe je dat niet zal de boel blijven hangen op één display wat verlicht is. En kan je zeggen, dat multiplex ik toch niet? Wat ik al zei, het is meer een van de dingen die je niet kunt. Gewoon maar domweg wachten (en een seconde is een heeeeeeeeeeeeeele lange tijd voor een microcontroller die werkt op 16MHz) is gewoon geen slimme zet. Is alsof je een eitje gaat koken, je timer op 5 minuten zet en na 2 minuten wel zien dat de boel in de fik is gevlogen maar niets doen tot je timer is afgelopen....

Waarom ik begin met een check hoeveel foto’s er gemaakt moeten worden. Bij het beginnen met het zoeken hoe ik de code moest gaan schrijven kwam ik dit tegen en ik begrijp wat er bedoeld word.
Ik wil altijd bijleren, dus heb weer wat leesvoer voor het weekend. :slight_smile:

septillion:
En dan nog twee vragen die ik al eens eerder had aangeduid. Voor beide geldt dat je keuze niet fout is ofzo, maar gewoon dingen doen zonder reden is eigenlijk de slechtste methode :smiley: En waarschijnlijk heb je wel een reden maar voor onze gedachten zou je de reden willen uitleggen?

Allereerst lijk je niet van de wijs te brengen over hoe je het aantal foto’s wilt instellen :smiley: Nu is er niets mis met een standen schakelaar natuurlijk maar hiermee beperk je jezelf wel tot 3 standen (1, 2 of 3 foto’s). Dit terwjl je alles hebt om met een simpele drukknop het aantal foto’s in te kunnen stellen tussen 1 en 9 (want dat past makkelijk op je scherm). Gebruikt maar één pin, is flexibeler, simpel drukknopje kan op de printplaat en is goedkoop, scheelt draden (draden zijn evil, zitten altijd in de weg en kosten altijd meer tijd om aan te sluiten dan je denkt) enz Maar goed, wat ik zei, standen schakelaar is ook niet fout maar vroeg me vooral af waarom jij dit verkiest.

En dan nog je status ledjes, wat vind jij hier de meerwaarde van? Zoals gezegd, ready snap ik nog wel (zeker als je dit de verlichting van de knop maakt) maar procces en finish? Het aftellen lijkt me voor de mensen een duidelijkere indicatie dat de boel gestart is. En finisch is toch gewoon hetzelfde als ready? Als je klaar bent met de foto’s ben je ook klaar voor een nieuwe ronde. Weer, kan het mis hebben vandaar de vraag naar je redenatie.

Vraag 1 : ik heb nog een aantal schakelaars(3) liggen die ik hiervoor wil gebruiken en een drukknop moet ik kopen. En op meer dan 3 foto’s ga ik hem toch niet instellen.

Vraag 2 : Zo had ik het bedacht in het begin, als ik het ga inbouwen kan ik altijd nog beslissen of ik die leds er inzet of toch weg laat. Dan is het alleen een kwestie van een aantal regels uit de code halen.

jeffrl:
Die functies , schrijf0, schrijf1, schrijf2, schrijf3 en schrijf10 lijken idd op elkaar.
Maar ik snap liever een code die langer is, dan een korte code die ik niet snap en knip en plak.

Maar heel lastig lijkt me het concept hier niet :wink: Ipv een hele slof fuctions schrijf1, schijf2 etc maak je een functie schrijf waar je de waarde als parameter in mee geeft. Dus schrijf(5) etc.

En als je code niet snapt kan je het altijd vragen. Sommige dingen zijn misschien wat te exteem om n gelijk te leren maar heel veel is met duidelijke uitleg (vandaar dat goed commentaar in de code zo belangrijk is) goed te begrijpen.

Om de eerste code uit te leggen. Daar maken ze een array aan met de 10 mogelijkheden die het display moet kunnen tonen. (Array kan je makkelijk opzoeken).

byte seven_seg_digits[10][7] = { { 1,1,1,1,1,1,0 },  // = 0
                                 { 0,1,1,0,0,0,0 },  // = 1
                                 { 1,1,0,1,1,0,1 },  // = 2
                                 { 1,1,1,1,0,0,1 },  // = 3
                                 { 0,1,1,0,0,1,1 },  // = 4
                                 { 1,0,1,1,0,1,1 },  // = 5
                                 { 1,0,1,1,1,1,1 },  // = 6
                                 { 1,1,1,0,0,0,0 },  // = 7
                                 { 1,1,1,1,1,1,1 },  // = 8
                                 { 1,1,1,0,0,1,1 }   // = 9
                                 };

Iedere lijn hierin is een invulling van de array (maar zelf ook weer een array). En wat het zegt is, voor een 0 moet segment A, B, C, D, E en F aan en G uit (aangezien je de pinnen ook van A tm G hebt aangesloten is dat hier ook in volgorde). Voor een 1 moet segment A uit, B en C aan en de rest ook uit. Enz. Zelfde segmenten aan een uit zoals je nu iedere keer hebt gedaan.

Nu heb je voor ieder getal en ieder segment staan of deze aan of uit moet zijn. Wil je een 0 zijn deze opgeslagen in seven_seg_digits[0][0] voor segment A tm seven_seg_digits[0][6] voor segment G. En voor bijvoorbeeld een 5 in seven_seg_digits[5][0] tm seven_seg_digits[5][6] enz. In de functie sevenSegWrite() geeft je aan welk getal je wilt schrijven (de byte digit), dit getal wordt ook gebruikt om in de array de juiste rij te selecteren. Vervolgens wordt er met de for() ieder segment langs gelopen. De for() loopt van segCount = 0 tm segCount = 7 en doet dan digitalWrite(pin, seven_seg_digits[digit][segCount] voor ieder segement.

Nu moet ik wel zeggen dat dit verder geen mooie functie is omdat het direct pin als parameter gebruikt. Maar na het lezen van mijn uitleg snap je hopelijk wel wat het doet. een for() loop in combinatie met een array is een hele krachtige manier om makkelijk bijna hetzelfde voor ieder ding (in dit geval ieder segment) te doen zonder dat uit te moeten schrijven door ieder geval apart.

jeffrl:
Dus ik ga me inlezen op die libray en kijken of ik er wijs uit word.

Bij een library hoef je de code daarin niet precies te snappen. Functies als digitalWrite() enz komen namelijk ook al voort uit (ingebakken) libraries. En als je doe code zou zien zou je nu ook niet weten wat het doet. Als je maar weet hoe je een library kunt gebruiken. Dat is juist de hele kracht van een library.

jeffrl:
Vraag 1 : ik heb nog een aantal schakelaars(3) liggen die ik hiervoor wil gebruiken en een drukknop moet ik kopen. En op meer dan 3 foto's ga ik hem toch niet instellen.

Duidelijk! Bedenk wel dat de schakelaar werkt als
stand 1 => pin A met middelste pin verbonden
stand 2 = > geen pin verboden
stand 3 => pin B met middelste pin verbonden

Jij gaat uit van een andere volgorde met als gevolg dat je nu de volgorde 1 foto, 3 foto en dan 2 foto hebt gekregen terwijl 1, 2 en dan 3 me logischer lijkt :smiley:

jeffrl:
Vraag 2 : Zo had ik het bedacht in het begin, als ik het ga inbouwen kan ik altijd nog beslissen of ik die leds er inzet of toch weg laat. Dan is het alleen een kwestie van een aantal regels uit de code halen.

Ook duidelijk! maar denk wel dat finish alleen meer complexiteit toe voegt. Je vroeg namelijk eigenlijk gewoon een extra state toe. Na de laatste foto ga je naar finish, wacht je, en ga je naar ready. Maar zodra de laatste foto genomen is zou je ook gewoon gelijk weer naar ready kunnen gaan. Want want wat wil je bijvoorbeeld dat er zou gebeuren als je finished bent en mensen drukken al op de knop? Moet hij dan weer beginnen met aftellen of wil je doelbewust dat mensen moeten wachten voordat ze een nieuwe serie foto's kunnen maken?