Jan krijgt Arduino-les op school, en hij vond dat wel wijs, en dus had hij weinig subtiel laten weten dat hij graag ook Arduinodingen zou doen thuis.

De vrienden van DealExtreme hebben extreme deals, en onder het motto een lichte overdaad kan geen kwaad, hebben we nu dus meer sensoren dan we een stok naar kunnen schudden in huis, en een lcd-scherm, en joysticks en allerlei waar ik nul verstand van heb.

Ik weet nog altijd niet hoe ik ook door mijn studies geraakt ben op school. In principe deed ik een wetenschappelijke richting, en ik herinner mij vaag dat er een hele tijd sprake was van electriciteit, dat ik ooit zelfs van die schema’s moest tekenen en debuggen, maar bij gebrek aan toepassingen is dat nooit langer dan een semester blijven hangen.

Maar nu dus die Arduino.

Ik snap het concept min of meer, en ik ben samen met Jan op verkenning gegaan.

Eerste probleem: Jan leert het op school eerst met Ardublock, een soort Scratch-achtige interface, maar dat werkt niet meer met de laatste versie, dus was het in code te doen.

Eerst een simpel circuit gemaakt, van pin 3 naar het breadboard en dan door een weerstand en naar een LED, en dan terug naar grond. Een simpel scriptje geschreven:

void loop() {
  analogWrite(3, 255);
  delay(500);
  analogWrite(3, 0);
  delay(500);
}

Dat doet wat een mens ervan zou verwachten: zeggen dat de snok naar 3 veel moet zijn en dan wachten en dan dat de snok niets moet zijn en weer wachten en terug herbeginnen.

So far so good. Tweede poging: twéé lichtjes. Alletwee na elkaar, en ziet nu: dat werkt, ze knipperen samen.

Derde poging: verkeerslichten! Een rood, een oranje euh geel wegens geen oranje, en een groen.

En dan proberen groen, oranje, rood en herbeginnen:

void loop() {
  analogWrite(1, 255);
  delay(3000);
  analogWrite(1, 0);
  analogWrite(2, 255);
  delay(1000);
  analogWrite(2, 0);
  analogWrite(3, 255);
  delay(3000);
  analogWrite(3, 0);
}

Ow, maar da’s allemaal onleesbaar en onduidelijk. Tijd om Jan het concept can variabelen te tonen:

int groen = 1;
int geel = 2;
int rood = 3;

int aan = 255;
int uit = 0;

void loop() {
  analogWrite(groen, aan);
  delay(3000);
  analogWrite(groen, uit);
  analogWrite(geel, aan);
  delay(1000);
  analogWrite(geel, uit);
  analogWrite(rood, aan);
  delay(3000);
  analogWrite(rood, uit);
}

Hoera!

Tijd om nog wat loops te doen: wat als we het oranje licht een paar keer laten knipperen vóór het op rood springt?

Dat kan zo:

analogWrite(geel, aan);
delay(1000);
analogWrite(geel, uit);
delay(100);
analogWrite(geel, aan);
delay(100);
analogWrite(geel, uit);
delay(100);
analogWrite(geel, aan);
delay(100);
analogWrite(geel, uit);
delay(100);
analogWrite(geel, aan);
delay(100);
analogWrite(geel, uit);
delay(100);
analogWrite(rood, aan);

Maar da’s een beetje achterlijk, wat als we het tien keer zouden willen doen?

Dus zo kan het ook, ziet:

int teller = 0;

while (teller <= 4) {
  analogWrite(geel, aan);
  delay(100);
  analogWrite(geel, uit);
  delay(100);
  teller = teller + 1;
}

Hoera een loop!

En als we toch al een loop hebben, dan kunnen we misschien eens proberen om het licht van 0 naar 255 te laten gaan en te zien wat dat geeft?

In plaats van

analogWrite(geel, aan);

doen we dan

int helderheid = 0;

while (helderheid <= 255) {
  analogWrite(groen, helderheid);
  delay(10);
  helderheid = helderheid + 5;
}

En hoera! Dat dimt het groen aan, in plaats van het meteen aan te steken!

Maar als we dat voor elk licht willen doen, zouden we dat drie keer moeten schrijven, terwijl het ook zo kan:

void aandimmen(int kleur) {
  int helderheid = 0;
  while (helderheid <= 255) {
  analogWrite(kleur, helderheid);
  helderheid = helderheid + 5;
  delay(10);
}

en dan

aandimmen(groen);
aandimmen(geel);
aandimmen(rood);

…maar wat als we de snelheid van het dimmen zouden willen instellen? En als het zowel aan- als afdimmen zou moeten zijn?

Enfin, een beetje gedoe later was het dit scriptje geworden:

Er gaan geen prijzen mee gewonnen worden, maar op geen tijd was Jan toch mee met variabelen en loops en booleans en functies en al.

En dit was het resultaat:

AAARGH. Het werkt niet! Het groene lampje doet een propere aan- en uitdimming, maar oranje en rood niet.

Het ligt niet aan de lamp zelf (we hebben lampen verstoken en als ik een andere lamp op de plaats van de rode of gele zet, werkt het ook niet). Het ligt niet aan de groene lamp (andere groene lampen werken ook niet op andere plaatsen, en andere kleuren werken op de plaats van de groene).

Ik heb het zelfs een gesimuleerd op circuits.io, en jawel: dat gaf hetzelfde. Alleen groen dimt, de rest niet.

Yep, da’s waar het een goed idee zou zijn om met iéts meer kennis van zaken aan de lag te kunnen gaan.

Ik weet niet waarom of hoe, maar als ik de lichten op pin 3, 5 en 7 zet, dan werkt het wel. En alleen op 3, 5, 7, 9, 10 en 11. Niet op 1, 2, 4, 6, 8, 12 en 13. Very weird:

Ah euh wacht. Als ik een beetje dichter kijk:

 

Er staat bij de pins waarmee het werkt een ~-tekentje. Ahem ja.

Een halve zoekopdracht later (“arduino 3 5 6 9 10 11”) weet ik nu dus dat er maar zes pins zijn met pulse width modulation, waarmee dimmen überhaupt kan werken.

Mysterie opgelost.

Pfff.

Misschien moet ik toch eerst wat meer lezen, voor ik dat LCD-scherm naar de knoppen help.