Lysstyring med Arduino 3

I første del af denne serie omtalte jeg de generelle betragtninger omkring styring af lys på min modelbane. I anden del så vi på de indledende øvelser for at lære at bruge en Arduino til at styre lysdioder - den handlede mest om hardware. Denne del kommer til gengæld udelukkende til at handle om software: Vi skal nu se på, hvordan vi for alvor får gavn af den hardware, vi stykkede sammen i anden del.

Der er mange på Sporskiftet, der leder efter den "rigtige løsning" på dette eller hint: Somme tider findes den, men meget ofte er der tale om, at det er et smagsspørgsmål, hvad man finder rigtigt. Der findes mange løsninger, og det er umuligt at sige, hvad der er den allerbedste for enhver. Dette gælder endnu mere for software: Når man skal skrive et computerprogram, er der aldrig nogen måde, der er "den rigtige". Ligesom man kan skrive en dansk stil på mange måder - og få gode karakterer for dem alle - kan man også skrive et computerprogram på mange måder. Faktisk er programmering en lige så individuel øvelse som et forfatterskab - ligesom den kyndige kan genkende en forfatter på sproget, er der også mange, der kan genkende programmøren på stilen.

Så når jeg nu kaster mig ud i programeksempler, skal det på ingen måde opfattes som "den rigtige" måde - kun som forslag til, hvordan man kan løse en given opgave.

Manglerne fra sidst

Sidste gang så vi på, hvordan man kunne koble en Arduino til computeren, lægge et program ind i den, og få en lysdiode til at blinke. Vi så på, hvordan man kunne ændre hardwaren, så man kunne sætte flere lysdioder på, og samtidigt regulere lysstyrken på dioderne; men fokus var på hardware - og vi så ikke rigtigt nærmere på, hvordan man kan styre mere end en lysdiode, og heller ikke på en praktisk styring af lysstyrken. Det skal det til gengæld handle om denne gang.

Mere præcist er der følgende udfordringer: Koden fra sidst styrer kun en lysdiode. Den kan kun have en lysstyrke. Og den blinker ikke særligt godt. Formålet med dette indlæg er at gøre noget ved disse problemer.

Bruger man en digital udgang på Arduinoen, kan den have værdien "0" eller "1": Man kan lave nogle julelege med en modstand, men omsat til lysdiodesprog betyder det stort set tændt eller slukket. Ved at indføre en TLC5940, får man pludseligt mulighed for at sætte lysstyrken: Den skal ikke blot tændes, når man vil have den til at lyse, skal man samtidigt fortælle, hvor kraftigt den skal lyse - og det er en helt anden situation.

Går vi tilbage til basis, handler det hele om belysning af huse: Jeg startede med print som disse

men her skal jeg beslutte diodernes lysstyrke, før jeg bygger printet ind i bygningen, og jeg har ingen mulighed for at forbedre mit koncept hen ad vejen. Med TLC kredsen kan jeg derimod nøjes med at trække ledningerne fra dioderne ud af bygningerne, og så kan jeg ellers styre lyset med en computer og et programmeringskabel - og jeg kan ændre det hen ad vejen lige så tosset, som jeg har lyst - og bliver dygtigere til.

Et bedre blink

En lysdiode reagerer lynhurtigt: Man kan tænde og slukke den millioner af gange i sekundet - den følger de elektriske signaler slavisk og meget præcist. Det er bl.a. derfor, man kan sende signaler med meget stor hastighed gennem en lysleder. En glødelampe er derimod meget langsom: Den fungerer ved, at man sender strøm gennem en glødetråd, der bliver varm og begynder at lyse op. Men netop kravet om, at den skal blive varm, betyder også, at den ikke tænder omgående, når man sætter strøm til: Glødetråden skal først blive varm, før lampen begynder at lyse. På samme måde slukker den ikke med det samme, når man fjerner strømmen - tråden skal først køle ned.

Tænd/sluk funktionen kommer derfor nemt til at se helt forkert ud, når man bruger lysdioder til at simulere glødelamper; og ingen steder ses det tydeligere, end når man har en blinkende lampe, der skal ligne en kraftig glødepære - som f.eks. i et daglyssignal. Med en Arduino og et TLC board er der til gengæld kun et spørgsmål om at skrive det rigtige program, så kan man lave en flot blinkende "glødelampe" på sit anlæg.

I afsnit 2 endte vi med noget kode, der tændte en lysdiode på fuldt knald, ventede et sekund, og slukkede den igen. Vente et sekund, tænde igen - og så har vi blinket med en frekvens på 0,5 Hz - en fuld cyklus tager 2 sekunder. Koden, der udfører det væsentlige arbejde, ser således ud:

// the loop routine runs over and over again forever:
void loop() {
  Tlc.set(led, 4095);        // turn the LED on (HIGH is the voltage level)
  Tlc.update();
  delay(1000);               // wait for a second
  Tlc.set(led, 0);           // turn the LED off by making the voltage LOW
  Tlc.update();
  delay(1000);               // wait for a second
}

Hvis vi vil have et bedre blink, kan vi imidlertid ikke nøjes med at tænde og slukke dioden: Lyset skal vokse langsomt fra 0 til fuld styrke, når man tænder, og dø langsomt ud igen, når man slukker. For at lave dette, kan vi lave en ny kode, der er lidt mere avanceret: Den første kode har kun tænd/sluk, men skal vi gennem software lave bløde overgange, er vi nødt til at have flere oplysninger. Vi skal vide, om dioden skal være tændt eller slukket, og vi skal vide, hvor kraftigt den lyser netop nu. Med disse to informationer er det muligt at lave noget kode, der giver et blødt blink.

Når man vil gemme information i et computerprogram, har man normalt brug for nogle variable til at gemme den i - så vi definerer to nye variable for vores lysdiode:

int led = 5;
int current = 0;
boolean state = LOW;

Jeg har her taget en tredie variabel med fra det tidligere program - nemlig den variabel, der definerer hvilken udgang dioden siddder på. To af variablerne er af typen int, mens den sidste er af typen boolean. int er en forkortelse af det engelske ord integer og betyder heltal: Værdien af disse kan skifte fra computerplatform til platform, men en Arduino benytter int med en præcision på 16 bit, hvilket i praksis betyder, at værdien kan gå fra -32.768 til 32.767. Mere end rigeligt til vores formål. En boolean er en helt anden variabeltype: Navnet kommer fra Boolsk algebra, og de to oo'er i navnet skal udtales som et langt u. Kort fortalt handler Boolsk algebra om at regne på logik, og en boolean variabel kan kun have to værdier: 0 eller 1 - som man til gengæld ofte omtaler som false eller true - eller som low eller high.

Boolsk algebra er en fascinerende disciplin, og det er i virkeligheden den form for matematik, der altid ligger i de allernederste lag af en computer. Da Arduinoen ligger meget nærmere disse nedre lag end man normalt er vant til, kommer man også til at arbejde meget med denne tankegang, end man plejer.

I det konkrete tilfælde giver det mening at bruge en boolean til at bestemme, om vores diode skal være tændt eller slukket: Der findes ikke rigtigt nogen mellemvej. Og så alligevel: Den anden variabel har jeg kaldt current, og det har en dobbelt mening - det engelske ord betyder såvel strøm som nuværende værdi, og denne variabel gemmer præcist denne information: Den nuværende værdi af strømmen gennem dioden. På TLC kredsløbet skal strømmen angives med et tal mellem 0 og 4095, så en variabel af typen int er perfekt til formålet.

Et bedre loop

Før vi kan gå videre med at lave et ordentligt blink til dioden, er vi nødt til at løse et alvorligt problem i den gamle kode: Koden virker - men den vil være svær at udbygge, så den kan bruges til noget seriøst. Problemet er den lange forsinkelse, vi har lagt ind i vores loop() funktion: Når man kalder delay(), sætter man effektivt computeren i stå i den tid, man har angivet. Skal man kun have en lysdiode til at blinke, gør det ikke noget - men skal computeren også udføre andre opgaver, er det meget, meget længe at stoppe den i et helt sekund. Vi skal jo senere have koblet nogle knapper på, så vi kan tænde og slukke lyset, og knapperne vil også skulle aflæses i loop() funktionen: Har man her en forsinkelse på 1 sekund, kan det tage op mod 1 sekund, før Arduinoen finder ud af, at man har trykket på en knap - og det vil føles som en ufattelig evighed.

Det er derfor vigtigt, at vi enten helt fjerner delay() funktionen fra vores loop() - eller i det mindste begrænser den til en meget lavere værdi. Det betyder så i næste åndedrag, at vi ikke længere kan bruge delay() funktionen direkte til at styre vores blink, så vi er nødt til at finde på noget mere avanceret kode. Lad os i første omgang prøve at skrive en kode, der kan køre uden delay() overhovedet. Det kræver, at vi finder en anden måde til at bestemme, om dioden skal være tændt eller slukket.

Arduinoen har en anden funktion, der hedder millis(): Den returnerer en værdi, der fortæller, hvor mange millisekunder, der er gået, siden Arduioen blev tændt. Den kan vi bruge, hvis vi kombinerer den med et par variable:

constant int frequency = 700;
unsigned long lastSwitch = 0;

Variablen frequency bruges til at bestemme blinkfrekvensen - men den indeholder ikke direkte et mål for frekvensen: Jeg har brugt værdien 700, og det skal forståes på den måde, at dioden skifter indstilling fra tændt til slukket eller tilbage igen med 700 mS mellemrum. Det betyder, at et helt blink kommer til at tage 1.400 mS - det giver i praksis en frekvens på omkring 1 / 1,4 = 0,7 Hz. Den anden variabel lastSwitch angiver, hvornår koden sidst har skiftet blink fra tændt til slukket eller omvendt. Den er af typen unsigned long - en 32 bit værdi, der kan gå fra 0 til 4.294.967.295. Det er vigtigt med en stor værdi, for denne variabel vil hele tiden tælle op, og når man når maksimumværdien, holder koden op med at virke. Det sidste kan man også programmere sig ud af - men med den herværende løsning kan koden køre i ca. 50 døgn uden at blive genstartet, så det må vist være godt nok til de fleste.

Hele den nye kode kan nu laves på denne måde - bemærk, at variablen state endnu ikke er kommet i brug:

#include "Tlc5940.h"
 
// Variable til lysdioden
 
boolean state = LOW;
int current = 0;
int port = 5;
 
// Variable til loop()
 
const int frequency = 700;
unsigned long lastSwitch = 0;
 
// Gør koden klar til brug
 
void setup() {
  Tlc.init();
}
 
// Kør selve koden
 
void loop() {
 
  // Hvis der er gået mere end frequency millisekunder
  // skal lysdioden skifte indstilling
 
  if (millis() > lastSwitch + frequency) {
    lastSwitch = millis();
 
    if (current == 0) {
      current = 4095;
    }
    if (current == 4095) {
      current = 0;
    }
  }
 
  // Skriv den aktuelle værdi til TLC kredsløbet
 
  Tlc.set(port, current);
  Tlc.update();
}

Lad os se på koden: Når programmet starter, er værdien af lastSwitch lig med 0. current er også lig med 0, så dioden er slukket. Programmet bliver ved med at køre i ring, men på et eller andet tidspunkt er der gået frequency millisekunder, og værdien af millis() bliver større end lastSwitch + frequency = 700. Programmet går derfor ind i if-kaldet, og det første, det gør, er at sætte lastSwitch til 700. Herefter sætter det current til 4095 - dvs. fuld power på lysdioden - hvis den er 0, og 0 hvis den er 4095. En tænd/sluk funktion. Når vi når til bunden af loop() sætter vi udgangen port til værdien af current, og starter forfra. Nu kører vi i ring med en tændt diode, indtil værdien af millis() bliver større end lastSwitch + frequency = 1.400. Så slukker vi dioden - og kører i ring igen.

På dette punkt kan vi forbedre programmet lidt: Hvis vi laver to nye variable, kan vi sætte lysstyrken for "tændt" og "slukket" til lige den værdi, vi har lyst til - og på den måde undgå, at dioden lyser med fuld styrke, hvis det ikke er det vi vil. Det ændrede program kan se således ud:

#include "Tlc5940.h"
 
// Variable til lysdioden
 
boolean state = LOW;
int current = 0;
int port = 5;
int lowValue = 0;
int highValue = 2048;
 
// Variable til loop()
 
const int frequency = 700;
unsigned long lastSwitch = 0;
 
// Gør koden klar til brug
 
void setup() {
  Tlc.init();
}
 
// Kør selve koden
 
void loop() {
 
  // Hvis der er gået mere end frequency millisekunder
  // skal lysdioden skifte indstilling
 
  if (millis() > lastSwitch + frequency) {
    lastSwitch = millis();
 
    if (current == lowValue) {
      current = highValue;
    }
    if (current == highValue) {
      current = lowValue;
    }
  }
 
  // Skriv den aktuelle værdi til TLC kredsløbet
 
  Tlc.set(port, current);
  Tlc.update();
}

Med de værdier, der er brugt her, vil dioden være helt slukket, når den er slukket, og lyse med halv styrke, når den er tændt; halv styrke, fordi 2048 er rundt regnet det halve af maksimalværdien på 4095.

En sidste forbedring af vores program kan være at sætte et lille delay() ind igen: Programmet burde køre fint uden, men på den anden side har vi ikke brug for, at det kører med så rasende et tempo, som det vil gøre uden delay(), det kan potentielt også skabe støj og ustabilitet, hvis vi opdaterer TLC kredsene i så højt et tempo, så det kan være smart at lade Arduinoen sove en lille smule mellem hver tur rundt i loop(). 50 mS kan være en god værdi, så den bruger vi her.

void loop() {
 
  // Hvis der er gået mere end frequency millisekunder
  // skal lysdioden skifte indstilling
 
  if (millis() > lastSwitch + frequency) {
    lastSwitch = millis();
 
    if (current == lowValue) {
      current = highValue;
    }
    if (current == highValue) {
      current = lowValue;
    }
  }
 
  // Skriv den aktuelle værdi til TLC kredsløbet
 
  Tlc.set(port, current);
  Tlc.update();
 
  delay(50);
}

Tilbage til blinket

Vi har nu en kode, der styrer blinket på en meget mere avanceret måde; men bortset fra en mere avanceret kode, har vi ikke vundet meget. Det kommer vi til gengæld til nu.

For at få lysdioden til at ligne en glødelampe, skal den tænde og slukke langsomt. Det er ikke godt nok blot at gå fra slukket til fuld styrke - det går alt for hurtigt; lysstyrken skal vokse langsomt, og forsvinde langsomt igen, når man slukker. Det kan heldigvis nemt klares med en Arduino.

void loop() {
 
  // Hvis der er gået mere end frequency millisekunder
  // skal lysdioden skifte indstilling
 
  if (millis() > lastSwitch + frequency) {
    lastSwitch = millis();
    state = !state;
  }
 
  // Sæt dioden til rette værdi afhængigt af state
 
  if (state == LOW) {
    current = lowValue;
  }
 
  if (state == HIGH) {
    current = highValue;
  }
 
  // Skriv den aktuelle værdi til TLC kredsløbet
 
  Tlc.set(port, current);
  Tlc.update();
 
  delay(50);
}

Lad os starte med at tage variablen state i brug. Denne variabel bestemmer, om dioden skal være tændt eller slukket, så det er den, vi skal ændre på, når der er gået frequency millisekunder. state er jo en variabel af typen boolean, så vi kan bruge boolsk algebra til at manipulere den: Linien state = !state; betyder: "Sæt state lig med not state". På mere normalt dansk betyder det, at man sætter state til den modsatte værdi af den, den har i øjeblikket: Er den 0, bliver den 1 - er den 1, bliver den 0. Det kaldes en negation i fagsproget, og udråbstegnet foran state til højre for lighedstegnet fortæller, at vi vil have denne negation.

Vi kunne naturligvis også have skrevet

if (state == LOW) {
  state = HIGH;
}
 
if (state == HIGH) {
  state = LOW;
}

men det er ikke nær så elegant, og det giver også en langt mere ineffektiv kode. Uden for vores if rutine sætter vi så efterfølgende lysstyrken afhængigt af værdien af state. Vi har nu en endnu mere kompliceret kode, der stadig laver præcist det samme som den første; men denne kode skal vi bruge til at lave det bløde blink.

Det er nu på tide at overveje en strategi: Grundideen med koden er, at vi i stedet for at sætte lysstyrken til enten minimum eller maksimum vil lade styrken skifte langsomt fra den ene værdi til den anden. Hvis vi vil tænde dioden, skal den derfor ikke skifte fra min til max med det samme, men i stedet tælle op fra min til max. Det kan vi grundlæggende gøre på to måder: Enten lægger vi en eller anden værdi til current, hver gang vi kører rundt i vores loop - eller også ganger vi current med en eller anden værdi for hver rundtur. Den første fremgangsmåde vil lade lysstyrken vokse lineært, mens den anden vil lade den vokse eksponentielt: Jeg vil undlade at redegøre for den matematiske forskel her, men nøjes med at konkludere, at det er den sidste metode, vi skal bruge her - lysstyrken skal vokse eksponentielt, og vi skal derfor gange værdien af current med en eller anden passende værdi, hver gang vi kører rundt i vores loop(). Når vi skal slukke dioden igen, skal vi på tilsvarende måde dividere med en konstant værdi.

Det er ikke så svært for en computer at gange to heltal med hinanden - men division er en helt anden historie: Computere elsker heltal, men har til gengæld stort besvær med decimaltal, brøker og andre upræcise værdier. Problemet med division er, at man ikke umiddelbart kan sige, om resultatet af divisionen bliver et pænt eller et besværligt tal: 4 / 2 giver 2, og det kan computeren sagtens håndtere - men 1 / 3 giver 0,3333 eller lige så mange decimaler, man har lyst til at sætte på, og det kan computeren ikke lide. Det kræver en masse CPU kraft af holde styr på en division, så det er, hvad man i programmørsprog kalder en dyr operation.

Det kan derfor være smart at bruge et andet standardtrick, man ofte finder i low level programmering: Shift left og shift right. For at forstå disse, bliver vi nødt til at se lidt på det binære talsystem. I 10-talsystemet er hvert ciffer mod venstre 10 gange større end det foregående: Vi har 1ere længst til højre, så kommer 10ere, så 100ere osv. For hvert ciffer mod venstre ganger vi med 10. I det binære talsystem har man samme logik, men her ganger man med 2 for hvert ryk mod højre: 1ere først, så 2ere, så 4ere, så 8ere osv. Vil vi gerne skrive 4 i det binære system, skal vi altså skrive 100: Ingen 1ere, ingen 2ere, og een 4er. Siger vi, at vi arbejder med en 8 bit computer, vil tallet 4 være repræsenteret som 00000100 i computerens hukommelse.

Det er ret vigtigt at forstå dette, hvis man vil forstå det følgende: I forklaringen vil vi hele tiden befinde os i dette "rum" af 8 bit værdier. 5 skrives altså som 00000101. Bruger vi computerens shift left funktion, vil den flytte alle bits en plads til venstre: Femtallet 00000101 bliver altså til 00001010. Det bit, der er yderst til venstre, går tabt, mens der automatisk fyldes et 0 på i højre side. Ser vi på den nye værdi 00001010, vil man se, at den svarer til decimale værdi 10. Vi startede med værdien 5, men ved at flytte det hele en plads til venstre, er vi endt med at få det dobbelte - 2 x 5 = 10. Man kan selv eksperimentere med andre værdier - det korte af det lange er, at en shift left kommando svarer til at gange: Skifter man to pladser til venstre, svarer det til at gange med 2² = 4, tre pladser 2³ = 8 og så fremdeles. Man bruger også disse kommandoer i andre sammenhænge, de har slet ikke al den intelligens, der ligger i en "rigtig" gange kommando, og man kan kun gange med potenser af 2. Til gengæld er de ekstremt effektive, de bruger næsten ingen computerkraft.

Det bliver endnu bedre med shift right: Her flytter man den anden vej - og det svarer naturligvis til at dividere. Men mens en generel divisionskommando er meget, meget dyr i CPU kraft, koster denne igen næsten ingenting. Disse kommandoer er ekstremt effektive - men igen kan man naturligvis kun dividere med potenser af 2.

Med denne introduktion kan vi for alvor begynde at forbedre vores program:

void loop() {
 
  // Hvis der er gået mere end frequency millisekunder
  // skal lysdioden skifte indstilling
 
  if (millis() > lastSwitch + frequency) {
    lastSwitch = millis();
    state = !state;
  }
 
  // Sæt dioden til rette værdi afhængigt af state
 
  if (state == LOW && current > lowValue) {
    current = current >> 1;
  }
 
  if (state == HIGH && current < highValue) {
    current = (current << 2) + 3;
  }
 
  // Skriv den aktuelle værdi til TLC kredsløbet
 
  Tlc.set(port, current);
  Tlc.update();
 
  delay(50);
}

På Arduinoen skrives shift left som current = current << 2; det betyder, at current sættes lig med værdien af current flyttet to pladser til venstre. Da vi ofte starter med en slukket diode og dermed værdien 00000000, hjælper det ikke kun at gange med 2: Vi lægger derfor 00000011 til værdien - det er det samme som decimaltallet 3. På den måde får vi nogle 1-taller at skifte løs med, så værdien kan blive større og større. Når vi går den anden vej er det lettere: Her starter vi med en stor værdi, som vi bliver ved med at dividere, indtil vi når 0. Her har jeg brugt kommandoen current = current >> 1; Sagt med andre ord ganger vi med 4, når vi ønsker at værdien skal blive større, mens vi kun dividerer med 2, når vi ønsker den skal blive mindre. Det svarer til, at dioden tænder dobbelt så hurtigt, som den slukker - og det ser rigtigt ud.

Det delay(), vi satte ind i loop() længere oppe, bliver nu igen vigtigt: Det påvirker ikke længere blinkfrekvensen, men det har til gengæld betydning for, hvor hurtigt dioden tænder og slukker. Det er svært at "dividere" med et tal mindre end 2, når vi ikke vil bruge en rigtig divisionskommando, så vi kan ikke sænke "slukkehastigheden" mere. Vil man derfor have en langsommere - eller hurtigere - "udglødning", er det delay() kommandoen, man skal justere på.

Den opmærksomme læser vil bemærke, at vi med denne fremgangsmåde ikke rammer den præcise værdi af f.eks. highValue, når vi skruer op for lyset - men i praksis rammer vi den præcist nok, øjet kan alligevel ikke registrere de små forskelle, der opstår med denne kode. Er man ikke tilfreds, kan man jo altid forbedre programmet; men jeg tror, man kommer til at skrive en masse ekstra kode uden at få noget særligt ud af det i praksis.

Forskellen på de to blink - dvs. med og uden langsom ændring - kan ses på disse to Youtube videoer, selvom det ikke virker helt så overbevisende som i virkeligheden; men jeg ved ikke, hvordan jeg kan filme det bedre.

Først det oprindelige blink uden forsinkelse:

og så den nye udgave med forsinkelse:

Det må vist være nok for denne gang. Næste gang skal koden udvides, så den kan styre mere end een lysdiode.