Arduino IDE

Utvecklingsmiljön består av en stor vit textruta där själva koden skrivs. Koden som skrivs där kallas sketch och lite längre fram i detta kapitel visar vi hur en sketch ser ut och hur den skrivs. Ovanför kodrutan finns knappar för sex av de vanligaste åtgärderna:

• verifiera en sketch
• kompilera och ladda upp en sketch till Arduino
• skapa en ny sketch
• öppna en befintlig sketch
• spara en sketch
• visa Serial monitor.

Vad de nämnda åtgärderna innebär och hur de används förklaras längre fram i detta kapitel.

Under kodrutan finns en svart ruta. Den använder utvecklingsmiljön för att berätta vad den håller på med. Den används också för att delge eventuella felmeddelanden. 

Utvecklingsmiljön fyller många funktioner. Den låter programmeraren göra bland annat dessa fyra saker på ett smidigt sätt:

• skriva kod (sketcher)
• verifiera kod
• kompilera kod
• ladda upp kod.

Sketchen beskriver vad Arduinon ska göra. Om vi exempelvis vill att en lysdiod ska blinka kan vi skriva en sketch för det. Om utvecklingsmiljön hade förstått svenska, hade vi kunnat skriva en kod som såg ut på följande vis.

Sätt GPIO-stift 13 som en utgång.

Gör följande saker om och om igen:
* slå på lysdiod på stift 13
* vänta 1000 millisekunder
* slå av lysdiod på stift 13
* vänta 1000 millisekunder.

Eftersom Arduino-utvecklingsmiljön inte förstår svenska måste vi skriva vår kod på ett språk som både vi och utvecklingsmiljön förstår: Arduino Programming Language (APL). Som tur är det går det lätt att översätta svenskan till APL! Då ser sketchen ut på följande vis. 

void setup() {
  pinMode(13, OUTPUT);
}

void loop() {
  digitalWrite(13, HIGH);
  delay(1000); 
  
  digitalWrite(13, LOW);
  delay(1000); 
}

BlinkLed.ino

Tips! Sketchen ovanför är den klassiska nybörjarsketchen inom Arduino-programmering. Faktum är att den redan finns på din dator! Klicka på Fil, Exempel, 01. Basics och välj Blink. På exempelmenyn hittar du många andra bra exempel som kan vara till stor hjälp när du skriver dina första sketcher. 

Sketchen består av två funktioner (vad en funktion är förklaras i Funktioner) som kallas setup respektive loop. Dessa två funktioner måste finnas med i alla sketcher, men avancerade sketcher har ofta fler funktioner. 

Allting som står i setup är det som Arduinon bara gör en gång (när den startar). Vi vill börja med att göra något med GPIO-stift 13. Det GPIO-stiftet har en lysdiod kopplat till sig (fastmonterat på utvecklingskortet), så vi behöver inte koppla någon hårdvara till utvecklingskortet för att testa denna sketch. 

Eftersom GPIO-stift 13 både kan användas som en ingång och som en utgång måste vi välja vilken funktion som GPIO-stiftet ska fylla. Jämför detta med när du konverserar med en vän. Få människor kan prata och lyssna samtidigt, så du måste bestämma dig för vilket av det du vill göra. Arduinon kan "prata" och "lyssna" på olika stift, men den kan inte prata och lyssna samtidigt på samma stift. Vi vill att GPIO-stift 13 ska användas som en utgång (för att "prata").

Allting som står i loop är det som Arduinon ska göra om och om igen. Vi vill att lysdioden på GPIO-stift 13 ska vara tänd i en sekund (1000 millisekunder) och därefter vara släckt lika länge. Så ska den fortsätta att växla läge i all oändlighet. Vi skriver därför att Arduinon först ska sätta hög spänning på GPIO-stift 13 (det får lysdioden att lysa) och därefter låg spänning på GPIO-stift 13 (det får lysdioden att slockna). För att lysdioden ska blinka i rätt takt åtskiljer vi de två instruktionerna med en fördröjning (ett delay). 

För att dokumentera vad vi gjort och vad vi vill åstadkomma lägger vi in kommentarer. Kommentarerna kan vi skriva på vilket språk som helst. Vi väljer att skriva dem på engelska eftersom det har blivit standardspråket för kommentarer i programmeringskod. Om vi skulle ladda upp vår sketch på ett forum för att få hjälp med felsökning är det praktiskt om alla som läser sketchen kan förstå kommentarerna. 

Vi inleder alla kommentarer med två snedstreck (//). Detta indikerar för utvecklingsmiljön att allt som kommer efter på samma rad är kommentarer och inte något som hör till själva programmet. Välskriven kod är alltid väldokumenterad, så att även andra programmerare kan förstå vad koden gör!

https://github.com/kjellcompany/Arduino_701/blob/master/BlinkLedBinary/BlinkLedBinary.ino

Prova att skriva sketchen på din dator. Lägg märke till att det finns många skiljetecken med i koden. Dessa skiljetecken måste skrivas för att koden ska tolkas rätt. 

När du har skrivit sketchen kan du spara den på din dator genom att klicka på Spara-knappen eller välja Spara på Fil-menyn. Välj ett filnamn som enbart består av bokstäverna A till Z. 

Tips! Du kan välja var dina sketcher sparas som standard i inställningsrutan som du når via Fil-menyn. 

Vi människor är ganska bra på att förstå varandra även om vi inte uttrycker oss hundra procent korrekt. Våra datorer (inkl. Arduino) är däremot värdelösa på att förstå vad vi menar om vi inte uttrycker oss korrekt. 

Om du får frågan "vill du ha ett äpple eller ett päron" svarar du troligtvis antingen "ett äpple" eller "ett päron". Om en dator får motsvarande fråga svarar den "ja" eller "nej"! För att datorn ska förstå frågan måste den omformuleras till: vill du ha "ett äpple", "ett päron", "varken ett äpple eller ett päron" eller "både ett äpple och ett päron"?

Vi kan slarva med stavning och grammatik när vi skriver på svenska, men när vi skriver APL måste vi uttrycka oss helt korrekt. Stavar vi fel på ett ord förstår inte datorn vad vi menar. Slarvar vi med grammatiken (som i programmeringsvärlden kallas syntaxen) förstår datorn inte heller vad vi menar. Syntaxreglerna i APL är lyckligtvis lättare att lära sig än grammatiken i svenskan. 

Likt rättstavningsprogrammet i Microsoft Word kan verifieringsfunktionen i Arduino IDE hjälpa oss kontrollera sketchen som vi har skrivit. Prova att klicka på Verifiera-knappen och se om sketchen du skrev är korrekt.

Verifieringsfunktionen i Arduino IDE fungerar som en rättstavningsfunktion.

Verifieringsfunktionen i Arduino IDE kan till och med hjälpa dig att korrigera en felskriven sketch. Om du exempelvis tar bort det sista semikolonet från din sketch och försöker att verifiera den på nytt kommer verifieringsfunktionen ge följande anmärkning.

Verifieringsfunktionen anmärker på att det borde finnas ett semikolon före denna slutparentes.

Tips! När communityn hjälper till med felsökning hänvisas ofta till radnummer.  Genom att slå på radnummersvisning blir det lättare att felsöka. Klicka på Fil-menyn, välj ­Inställningar och Visa radnummer.

Slå på radnummersvisning för lättare felsökning. 

Efter att ha läst denna bok kommer du att förstå APL. Det kommer dock aldrig din Arduino att göra! Den förstår enbart maskinkod, det vill säga kombinationer av ettor och nollor som instruerar Arduinon att göra något. Sketchen som du har skrivit måste därför kompileras. 

Att kompilera något innebär att ta källkoden som programmeraren har skrivit (sketchen) och översätta den till maskinkod som datorn kan köra. Kompilatorn finns inbyggd i utvecklingsmiljön, så det räcker med att trycka på en knapp för att få sketchen kompilerad. Faktum är att du redan har kompilerat kod en gång! När du verifierade sketchen tidigare i detta kapitel, skickade du den till kompilatorn för att se om den kunde göra om din källkod till maskinkod. 

Kompilatorn är en fantastisk uppfinning. Utan den hade vi behövt skriva kod som ser ut på följande vis (maskinkoden i exemplet är den du får när du kompilerar din sketch).

:100000000C945C000C946E000C946E000C946E00CA
:100010000C946E000C946E000C946E000C946E00A8
:100020000C946E000C946E000C946E000C946E0098
:100030000C946E000C946E000C946E000C946E0088
:100040000C9488000C946E000C946E000C946E005E
:100050000C946E000C946E000C946E000C946E0068
:100060000C946E000C946E00000000080002010069
:100070000003040700000000000000000102040863
:100080001020408001020408102001020408102002
:10009000040404040404040402020202020203032E
:1000A0000303030300000000250028002B000000CC
:1000B0000000240027002A0011241FBECFEFD8E043
:1000C000DEBFCDBF21E0A0E0B1E001C01D92A930AC
:1000D000B207E1F70E9403020C9413020C94000093
:1000E00061E08DE00C94930161E08DE00E94CC0111
:1000F00068EE73E080E090E00E94F50060E08DE043
:100100000E94CC0168EE73E080E090E00C94F50072
:100110001F920F920FB60F9211242F933F938F933C
:100120009F93AF93BF938091010190910201A091A1
:100130000301B09104013091000123E0230F2D371A
:1001400020F40196A11DB11D05C026E8230F0296DB
:10015000A11DB11D20930001809301019093020124
:10016000A0930301B09304018091050190910601D1
:10017000A0910701B09108010196A11DB11D8093C6
:10018000050190930601A0930701B0930801BF9168
:10019000AF919F918F913F912F910F900FBE0F9034
:1001A0001F9018953FB7F894809105019091060132
:1001B000A0910701B091080126B5A89B05C02F3F6B
:1001C00019F00196A11DB11D3FBF6627782F892F19
:1001D0009A2F620F711D811D911D42E0660F771FDE
:1001E000881F991F4A95D1F708958F929F92AF92D9
:1001F000BF92CF92DF92EF92FF926B017C010E943F
:10020000D2004B015C01C114D104E104F104F1F00E
:100210000E9412020E94D200681979098A099B097A
:10022000683E73408105910570F321E0C21AD10840
:10023000E108F10888EE880E83E0981EA11CB11C2D
:10024000C114D104E104F10429F7DDCFFF90EF9050
:10025000DF90CF90BF90AF909F908F90089578944B
:1002600084B5826084BD84B5816084BD85B58260BB
:1002700085BD85B5816085BDEEE6F0E08081816059
:100280008083E1E8F0E01082808182608083808159
:1002900081608083E0E8F0E0808181608083E1EB31
:1002A000F0E0808184608083E0EBF0E08081816019
:1002B0008083EAE7F0E080818460808380818260CF
:1002C00080838081816080838081806880831092B8
:1002D000C1000895833081F028F4813099F0823094
:1002E000A1F008958730A9F08830B9F08430D1F4B6
:1002F000809180008F7D03C0809180008F778093F4
:100300008000089584B58F7702C084B58F7D84BD49
:1003100008958091B0008F7703C08091B0008F7DE9
:100320008093B0000895CF93DF9390E0FC01E458F0
:10033000FF4F2491FC01E057FF4F8491882349F13E
:1003400090E0880F991FFC01E255FF4FA591B491F1
:100350008C559F4FFC01C591D4919FB7611108C086
:10036000F8948C91209582238C93888182230AC0F3
:10037000623051F4F8948C91322F309583238C9312
:100380008881822B888304C0F8948C91822B8C9373
:100390009FBFDF91CF9108950F931F93CF93DF936A
:1003A0001F92CDB7DEB7282F30E0F901E859FF4F93
:1003B0008491F901E458FF4F1491F901E057FF4F80
:1003C00004910023C9F0882321F069830E946A0107
:1003D0006981E02FF0E0EE0FFF1FEC55FF4FA59174
:1003E000B4919FB7F8948C91611103C0109581234B
:1003F00001C0812B8C939FBF0F90DF91CF911F91F4
:100400000F91089508950E942F010E9402020E94F8
:100410007000C0E0D0E00E9474002097E1F30E94D9
:0A0420000000F9CF0895F894FFCF13
:00000001FF

Maskinkoden här i boken är inte skriven med ettor och nollor (binärt). Det hade tagit alltför många sidor i anspråk. Vi har i stället skrivit koden med siffrorna 0 till 9 och bokstäverna A till F. Detta kallas hexadecimalt och används av programmerare som behöver ändra direkt i maskinkoden (vilket du lyckligtvis inte behöver göra tack vare kompilatorn). Den hexadecimala koden kan omvandlas till binär kod genom att helt enkelt ersätta sifforna och bokstäverna med följande kombinationer av fyra ettor och nollor. Läs mer om binära tal i datordelen av Hur funkar det?-serien om du är intresserad. 

Anledningen till att du kan ta till dig informationen i denna bok är att du kan läsa. Om du inte hade kunnat läsa, hade texten på dessa sidor inte fyllt någon funktion. Minns du hur du lärde dig att läsa? Det var troligtvis inte med hjälp av en tjock textbok som hette "Konsten att läsa". En ren textbok kan inte lära någon läsa eftersom den förutsätter att personen som läser den redan kan läsa. Du lärde dig troligtvis att läsa genom att du fick intryck från bilder, lärare och föräldrar som successivt gjorde att du förstod läskonceptet.

En mikrokontroller kan inte programmeras via USB. Den förstår inte vad det innebär att vara ansluten till en dator via USB. Precis som att vi inte kan läsa oss till hur vi ska läsa, kan inte heller en mikrokontroller lära sig använda USB-gränssnittet via USB-gränssnittet. Det ställer till problem på datorer som enbart är utrustade med USB-portar. 

Detta "moment 22" löses i Arduino-världen med hjälp av en så kallad bootloader. Det är en mjukvara som "bränns" till mikrokontrollern genom en speciell hårdvara. Vi ­behöver inte ha tillgång till någon sådan hårdvara eftersom bootloadern redan är inbränd i mikrokontrollern på Arduino Uno. 

Tack vare den förinstallerade bootloadern kan vi använda programmeraren som sitter på utvecklingskortet för att programmera vår Arduino. Det är den som gör att vi kan ansluta vårt utvecklingskort till en dator och trycka på en knapp för att få maskinkoden överförd.

Att programmera en Arduino sker i fyra steg. Det första vi gör är att skriva vår sketch (vår källkod⁵). Det gör vi i programmeringsspråket APL. Det andra vi gör är att verifiera koden så att vi inte har gjort några misstag. Om verifieringen går igenom kan vi kompilera vår källkod och få ut maskinkod. Den maskinkoden kan vi avslutningsvis, tack vare bootloadern, ladda upp till Arduinon och få Arduinon att göra något. 

Sammanfattning över processen

Avsluta nu kapitlet med att göra just detta. Klicka på Ladda upp-symbolen så kommer utvecklingsmiljön att verifiera, kompilera och ladda upp din sketch. När maskinkoden laddas upp till Arduinon kommer TX- och RX-lysdioderna på utvecklingskortet blinka intensivt. Därefter kommer lysdioden som är kopplad till GPIO-stift 13 att blinka långsamt. 

Tips! Du kan ändra hur snabbt lysdioden blinkar genom att ändra värdet som står inom parentes i delay(). 

När maskinkoden är överförd till Arduinon behöver den inte längre vara kopplad till datorn. Allt den behöver ligger i mikrokontrollern. Det innebär att du kan koppla ­utvecklingskortet till exempelvis en powerbank med USB-port och använda din blinkande Arduino var du vill. Du kan även driva den på ett 9 V-batteri.

5. Även känt som "Kjellkod".