Hulp voor code TL verlichting 3 polige schakelaar

[nathanv Profiel Privébericht]

Ik probeer voor een school project een schakeling te maken.
De volgende onderdelen zitten in dit project.

1: Arduino uno
2: Led lamp
3: 3 plolige schakelaar

Een omschrijving van de functie.

programma A : De led lamp gaat knipperen (na bootsen van een oude TL buis) en blijft dan aan.
Programma B : De led lamp in een keer aan gaan.
De programma's moeten gewisseld kunnen worden zonder een power circle of reset uit te moeten voeren.

Ik blijf alleen tegen de volgende probleem aan lopen dat bij programma A ik de led lamp niet aan kan laten en de mogelijkheid behoud om te kunnen wisselen tussen de verschillende programma's.

Code: Alles selecteren

 
  int ProgramA = 2;                          // Programma schakelaar A input zit op D2.
  int ProgramB = 4;                          // Programma schakelaar B Input zit op D4.
  int Ledlamp = 12;                          // Ledlapm zit op D12.
 
void setup() {
  pinMode(Ledlamp, OUTPUT);                   // LED lamp output 12:.
                                             
  pinMode(2, INPUT);                          // Programma schakelaar A input.
  pinMode(4, INPUT);                          // Programma schakelaar B Input.

  Serial.begin(9600);                         // Serial monitor voor debuging.

}

void loop() {
 //Program A
 if (digitalRead(ProgramA)= HIGH) {           // Als Input 2 hoog is start het programma A.
     digitalWrite(12, HIGH);                  // zet led lamp aan.
     
 int StateA = digitalRead(ProgramA);          // Lees waarde uit pin de genoemde pin

 Serial.println(StateA);                      // Zet de gevraagde waarde in het scherm
 
 //Program B
 if (digitalRead(ProgramB) = HIGH) {          // Als Input 4 hoog is start het programma B.
     digitalWrite(12, HIGH);                  // zet led lamp aan.
     
 digitalWrite(Ledlamp, HIGH);                 // Zet led lamp aan.
 delay(100);                                  // Vertraging van X.
 digitalWrite(Ledlamp, LOW);                  // Zet led lamp uit.
 delay(100);                                  // Vertraging van X.
 digitalWrite(Ledlamp, HIGH);                 // Zet led lamp aan.
 delay(300);                                  // Vertraging van X.
 digitalWrite(Ledlamp, LOW);                  // Zet led lamp uit.
 delay(100);                                  // Vertraging van X.
 digitalWrite(Ledlamp, HIGH);                 // Zet led lamp aan.
 delay(200);                                  // Vertraging van X.
 digitalWrite(Ledlamp, LOW);                  // Zet led lamp uit.
 delay(50);                                   // Vertraging van X.
 digitalWrite(Ledlamp, HIGH);                 // Zet led lamp aan.
 delay(100);                                  // Vertraging van X.
 digitalWrite(Ledlamp, LOW);                  // Zet led lamp uit.
 delay(100);                                  // Vertraging van X.
 digitalWrite(Ledlamp, HIGH);                 // Zet led lamp aan.
 delay(1000);                                 // Hier moet de led lamp blijven branden daarom is de vertaging zo hoog.
 
 }
}

[Koepel Profiel Privébericht]

Als je een goede beschrijving maakt, dan rolt het programma daar bijna vanzelf uit (nou ja, niet helemaal vanzelf natuurlijk ).

Je hebt twee schakelaars. Zijn dat drukknopjes die je even indrukt, of zijn dat echt schakelaars die 'aan' blijven als je ze 'aan' zet.
Wat wil je doen als beide schakelaar 'aan' zijn ?

Stel dat je schakelaars hebt en je wilt een TL-buis nabootsen. Dan wil je eenmalig dat knipperen doen. Dat betekent dat het moment dat de schakelaar 'aan' gaat belangrijk is.
Om iets te doen op dat ene moment, daar is de State Change Detection voor: https://www.arduino.cc/en/Tutorial/BuiltInExamples/StateChangeDetection.

Met twee schakelaars heb je twee van die State Change Detection dingen nodig.
Dan kun je iets doen op het moment dat een schakelaar 'aan' en 'uit' gaat. Voor twee schakelaars zijn dat vier momenten ("events").
Eventueel is het niet nodig voor de knop die de led gewoon 'aan' en 'uit' zet, maar het lijkt mij duidelijker en gemakkelijker om het voor beide schakelaars te doen.

Je doet nu twee keer een digitalRead(ProgramA) in de loop(), terwijl er maar één knop is. Het is netter om dan ook maar één keer de knop op te vragen.

Kijk eens op deze pagina: https://www.arduino.cc/reference/en/language/structure/control-structure/if/.
En dan vooral bij "equal".

Code: Alles selecteren

if( peer == RIJP)
{
  eetPeer(); 
}

Ik zou met random() het knipperen simuleren. Kun je er nog een zoemertje bij doen voor het "bzzzzz bzzzz plink plink" geluid ?

Aanvulling: ik denk dat ik iets heb:

Code: Alles selecteren

// Nabootsen TL buis geknipper bij aanzetten.

const int ledPin = LED_BUILTIN;

void setup()
{
  pinMode( ledPin, OUTPUT);

  delay( 2000);  // even wachten voordat het begint.
}

void loop()
{
  int i, n;
 
  // Eerste fase, af en toe springt de TL buis even aan.
  n = random( 1, 5);
  for( i=0; i<n; i++)
  {
    delay( random( 200, 1000));
    digitalWrite( ledPin, HIGH);
    delay( random( 20, 50));
    digitalWrite( ledPin, LOW);
  }

  // Tussen fase, overgangsfase
  n = random( 1, 3);
  for( i=0; i<n; i++)
  {
    delay( random( 100, 400));
    digitalWrite( ledPin, HIGH);
    delay( random( 30, 150));
    digitalWrite( ledPin, LOW);
  }

  // Volgende fase is vreemd geknipper, waarbij de TL buis meestal aan is.
  n = random( 4, 15);
  for( i=0; i<n; i++)
  {
    delay( random( 10, 100));
    digitalWrite( ledPin, HIGH);
    delay( random( 50, 300));
    digitalWrite( ledPin, LOW);
  }

  // Laatste fase is aan
  digitalWrite( ledPin, HIGH);

  // Laat de led aan voor 5 seconden
  delay( 5000);
  digitalWrite( ledPin, LOW);

  delay( 5000);    // even wachten voor de volgende
}


Je zou het knipperen in een functie kunnen zetten, zodat je in je sketch kunt schrijven welke functie je aanroept. Als je zelf geknipper maakt, en die van mij er als extraatje bij zet met een link naar dit forum, dan neem ik aan dat het geen probleem is.

[shooter Profiel Privébericht]

je zult dus ook moeten bedenken wat er gebeurt als de schakelaar UIT staat.

lees eens hoe time without delay maar met een millis werkt dan leer je ook nog iets.
als je alle opdrachten onder elkaar zet kun je best een goed programma maken. je begin is prima.

[nathanv Profiel Privébericht]

Koepel bedankt voor je tip. Ik moest je code even bekijken om hem uit te werken/ te begrijpen maar dit is een mooie aanwinst voor mijn code.
Ik gebruik een schakelaar met 2 on standen, ik schakel de 5v. De stand van de schakelaar blijft staat totdat ik hem handmatig overzet.

Persoonlijk snap ik niet wat het extra nut is van de ''state change detection'' hier ga ik nog veder wat onderzoek naar doen.
Koepel zou jij me kunnen helpen wat ik snap niet zo goed hoe je dan de random moet activeren met een button. Ik krijg het niet voor elkaar

If (digitalRead(ProgramB)== HIGH) start random??

Shooter ik ben vrij nieuw het Programmeren is het onderstaan een beetje een duidelijke omschrijving?

If Input 2 = HIGH Start programA (vast aan)
Else if input 4 = HIGH start programB (Knipperen)
Else 2&4 LOW= output 12 LOW

Ik nu ook in mijn code rekening gehouden met de optie dat er geen signaal binnen komt.
Ik heb mijn code hier onder toegevoegd met de aan passingen ik hoop dat het nu iets beter is.
Graag hoor ik van jullie

Code: Alles selecteren

  const int ProgramA = 2;                                // Programma schakelaar A input zit op D2.
  const int ProgramB = 4;                                // Programma schakelaar B Input zit op D4.
  const int Ledlamp = 13;                          // Ledlapm zit op D12.
                                                   
void setup() {
  pinMode(Ledlamp, OUTPUT);                         // LED lamp output 12.
                                             
  pinMode(ProgramA, INPUT);                         // Programma schakelaar A input.
  pinMode(ProgramA, INPUT);                         // Programma schakelaar B Input.

  Serial.begin(9600);                               // Serial monitor voor debuging.

}

void loop() {
 //Program A-1
   if (digitalRead(ProgramA)== HIGH);               // Als Input 2 hoog is start het programma A.
       digitalWrite(Ledlamp, HIGH);                 // zet led lamp aan.
     
 //Program B-1
   else if 9digitalRead (pragramB)== HIGH);         // Als Iput 4 hoog is strat het programma B.                                       
   int i, n;
   n = random( 1, 5);                               // Genereer een random getal tussen de 1 en 5.
   for( i=0; i<n; i++)                              // Als i kleiner is dan de n word de ciclus gestard en i + 1.
   {
    delay( random( 200, 1000));                     // Genereer een random getal tussen de 200 en 1000 voor aan tijd ledlamp.
    digitalWrite( Ledlamp, HIGH);                   // Lamp aan voor gegenereerde tijd.
    delay( random( 20, 50));                        // Genereer een random getal tussen de 20 en 50 voor uit tijd ledlamp.
    digitalWrite( Ledlamp, LOW);                    // Lamp uit voor gegenereerde tijd.
   }
   //Program B-2 
   n = random( 1, 3);                               // Genereer een random getal tussen de 1 en 3.                             
   for( i=0; i<n; i++)                              // Als i kleiner is dan de n word de ciclus gestard en i + 1.
   {
   delay( random( 100, 400));                       // Genereer een random getal tussen de 200 en 1000 voor aan tijd ledlamp.
   digitalWrite( Ledlamp, HIGH);                    // Lamp aan voor gegenereerde tijd.
   delay( random( 30, 150));                        // Genereer een random getal tussen de 20 en 50 voor uit tijd ledlamp.
   digitalWrite( Ledlamp, LOW);                     // Lamp uit voor gegenereerde tijd.
   }

   //Program B-3
   n = random( 4, 15);                              // Genereer een random getal tussen de 4 en 15.
   for( i=0; i<n; i++)                              // Als i kleiner is dan de n word de ciclus gestard en i + 1.
   {
   delay( random( 10, 100));                        // Genereer een random getal tussen de 10 en 100 voor aan tijd ledlamp.
   digitalWrite( Ledlamp, HIGH);                    // Lamp aan voor gegenereerde tijd.
   delay( random( 50, 300));                        // Genereer een random getal tussen de 30 en 300 voor uit tijd ledlamp.
   digitalWrite( Ledlamp, LOW);                     // Lamp uit voor gegenereerde tijd.
   }

 //Program B-4
   digitalWrite( Ledlamp, HIGH);
   
   
 // Geen input
    else (digitalRead (ProgramA) == LOW && digitalRead (ProgramB)== LOW;{
          digitalWrite( Ledlamp, LOW);                //Als er geen input signaal op 2 en 4 blijft de ledlamp uit
}
 
 

[Koepel Profiel Privébericht]

Eerlijk gezegd, dat je een "State Change Detection" nodig hebt is puur op gevoel

Ik ga even op de sofa liggen om over mijn gevoel te praten
De Arduino loop() functie wordt heel vaak uitgevoerd, en je hebt twee ingangen (de schakelaars) die iets doen met één uitgang (de led). Dat komt al snel met elkaar in de war, en dan is een "event driven" sketch duidelijker.

Met "event driven" bedoel ik een sketch die aangestuurd wordt door gebeurtenissen.
Bijvoorbeeld het omzetten van een schakelaar (dat ene moment) is zo'n gebeurtenis.

Als je dat niet doet en gewoon in de loop() kijkt hoe de stand van de schakelaar is, dan kijk je naar de "state" van de schakelaar.
Stel dat je het knipperen hebt gedaan, hoe weet je dan bij de volgende loop() dat de led gewoon aan moet blijven zonder het knipperen ? Dan heb je een extra variabele nodig om dat bij te houden. Dan kun je net zo goed een "State Change Detection" doen, want die gebruikt ook een variabele om iets bij de houden (de vorige stand van de schakelaar).

Ik hoop dat het iets duidelijker is

Dit is duidelijk:

If Input 2 = HIGH Start programA (vast aan)
Else if input 4 = HIGH start programB (Knipperen)
Else 2&4 LOW= output 12 LOW

Voor een goede omschrijving is het beter om "schakelaar1" en "schakelaar2" te gebruiken, want aan welke pin ze komen is niet belangrijk.

if schakelaar1 is 'aan', dan led vast aan
else if schakelaar2 is 'aan', dan led knipperen en daarna aanblijven
else led uit

Je hoeft niet te testen of beide schakelaars 'uit' zijn, want als ze geen van tweeën 'aan' zijn, dan moeten ze dus 'uit' zijn.

Je probleem is nog steeds dat als pin 4 een HIGH wordt, en je doet het knipperen, en de loop() wordt weer uitgevoerd, dan ga je weer knipperen, terwijl dan de led aan moet blijven. Daar heb je nog geen oplossing voor.

Een paar opmerkingen:

1. Gebruik eerst je eigen knipper code. Dat van mij is een geintje om later toe te voegen. Volg altijd de KISS regel: https://nl.wikipedia.org/wiki/KISS-principe.
Je sketch moeilijker maken kan altijd nog. Het gaat er nu eerst om dat je de structuur van de code in orde krijgt.

2. Het is duidelijker als je bij iedere 'if' en iedere 'else' de haakjes '{' en '}' gebruikt.
Een ';' op zichzelf is een leeg statement, dat "doe niets" betekend. Als je die achter een "if(conditie)" zet, dan wordt het if-statement afgesloten met een "doe niets".

Code: Alles selecteren

if (digitalRead(ProgramA) == HIGH);

// vertaling:
// als pin 'ProgramA' HIGH is, dan: doe niets


Je bedoelt waarschijnlijk dit:

Code: Alles selecteren

if (digitalRead(ProgramA) == HIGH)
{
  digitalWrite(Ledlamp, HIGH);
}
else
{
  ...


3. Het is iets gemakkelijker om in een variabele bij te houden of er al geknipperd is. Dus dat is ook een goede oplossing. Dan heb je de "State Change Detection" niet nodig
Je kunt globale variabelen gebruiken om van alles te onthouden, ongeacht hoe vaak de loop() wordt uitgevoerd.
Je kunt dus echt alles onthouden wat je wilt:
- Hoe vaak een schakelaar is omgezet.
- Of er al geknipperd is.
- Hoe lang er niets met de schakelaars wordt gedaan.
- enzovoorts.

[nathanv Profiel Privébericht]

Koepel als het goed is heb ik nu jou toevoeging's punten verwerkt in de code. Echter krijg ik program B-2 niet werkten zou jij hier naar kunnen kijken?

Code: Alles selecteren

  int ProgramA = 2;                                                         // Programma schakelaar A input zit op D2.
  int ProgramB = 4;                                                         // Programma schakelaar B Input zit op D4.
  int Ledlamp = 13;                                                         // Ledlapm zit op D12.
  int x = 0;                                                                // zet standaart waarde x op 0.
   
void setup(){
  pinMode(Ledlamp, OUTPUT);                                                 // LED lamp output 12.
                                             
  pinMode(2, INPUT);                                                        // Programma schakelaar A input.
  pinMode(4, INPUT);                                                        // Programma schakelaar B Input.
}

void loop(){
 
 //Program A
 if (digitalRead(ProgramA) == HIGH){                                        // Als Input 2 hoog is start het programma A.
     digitalWrite(Ledlamp, HIGH);}                                          // zet lamp aan.

 //Program B-1                                                             
 else if (digitalRead(ProgramB) == HIGH){                                   // Als Input 2 hoog is start het programma A.
          digitalWrite(Ledlamp, HIGH);                                      // zet lamp aan.     
          digitalWrite(Ledlamp, LOW);                                       // Zet led lamp uit.
          delay(100);                                                       // Vertraging van X.
          digitalWrite(Ledlamp, HIGH);                                      // Zet led lamp aan.
          delay(100);                                                       // Vertraging van X.
          digitalWrite(Ledlamp, LOW);                                       // Zet led lamp uit.
          delay(300);                                                       // Vertraging van X.
          digitalWrite(Ledlamp, HIGH);                                      // Zet led lamp aan.
          delay(100);                                                       // Vertraging van X.
          digitalWrite(Ledlamp, LOW);                                       // Zet led lamp uit.
          delay(200);                                                       // Vertraging van X.
          digitalWrite(Ledlamp, HIGH);                                      // Zet led lamp aan.
          delay(50);                                                        // Vertraging van X.
          digitalWrite(Ledlamp, LOW);                                       // Zet led lamp uit.
          delay(100);                                                       // Vertraging van X.
          digitalWrite(Ledlamp, HIGH);                                      // Zet led lamp aan.
          delay(100);                                                       // Vertraging van X.
          digitalWrite(Ledlamp, LOW);                                       // Zet led lamp uit.
          delay(100);                                                       // Vertraging van X.
          digitalWrite(Ledlamp, HIGH);                                      // Zet led lamp aan
          delay (1000);
          x=1;}
         
//Program B-2                                                           
  if (ProgramB == HIGH && x>=1){                                            // Als programma B-1 al gedraait heeft doe B-2.
  digitalWrite(Ledlamp, HIGH);
  x++;                                                                      // Maak ene optelling
  }
 
 // Als er geen input is.
 else digitalWrite( Ledlamp, LOW);{}                                         //Als er geen input signaal op 2 en 4 blijft de ledlamp uit
         
}

[Koepel Profiel Privébericht]

Kun je eerst even de variabelen een betere naam geven ?
Er is een pin nummer (bijvoorbeeld 2 of 4) en er is de waarde die digitalRead() van die pin kan lezen (HIGH of LOW). Die gooi je nu door elkaar.
Om die problemen te voorkomen is het beter om de term "pin" in de naam te zetten.
Bijvoorbeeld: SchakelaarPinA en SchakelaarPinB.
Maar korter kan ook: pinA en pinB.
Of: programA_pin en programB_pin.

Soms wordt de variabele waarin de waarde digitalRead() komt "value" genoemd.
int programA_value = digitalRead( programA_pin) ;
int valueA = digitalRead( pinA) ;

Het belangrijkste van programmeren is om een probleem uit de echte wereld in stukjes te kunnen opdelen en elk stukje op een goede en logische manier te kunnen omschrijven.

Kun je met je eigen woorden beschrijven wat variabele 'x' moet doen ? Op een manier die zo kort mogelijk is, maar wel alle mogelijkheden benoemt.
Iets goed beschrijven is nog niet zo eenvoudig, zoals deze "exact instructions challenge" laat zien: https://www.youtube.com/watch?v=cDA3_5982h8.