Läs gärna igenom hela texten innan du försvinner iväg på alla länkar som finns här.
Arduino®1 IDE (Integrated Development Environment eller på Svenska Integrerad Utvecklingsmiljö) bygger på öppen källkod skrivet i Java som bygger på Processing, AVR-GCC (kompilatorn) och andra öppna källkoder. Med Arduino® IDE är det möjligt att skiva kod i C/C++ och ladda upp det till målsystemet via USB (eller äldre kort via RS232). Fördelarna är många och för att nämna några så är det gratis, det finns för Windows, Mac OS och Linux och det är mycket lätt att komma igång med då man ofta inte behöver veta vad som händer i en microkontroller när den skall initieras upp (vilket kan vara en mardröm om det är första gången man kommer i kontakt med en microkontroller).
Arduino® finns inte till alla microcontrollers utan ett fåtal från Atmel’s AVR familj, den vanligaste som vi kommer att arbeta med här är ATMega328P som sitter på t.ex. Arduino® Uno och de tidigare Arduino® 2009 (duemilanove) samt många andra kompatibla utvecklingskort som finns ute på marknaden. Numera finns det även kort med Atmel ATMega32U4 samt Atmel ARM Cortex® M0+, men de är 3.3V och behandlas inte i dessa lektioner än. Inkörsporten är alltid de kort som har en ATMega328P.
När vi började med dessa lektioner baserades de på version 1.0 av Arduino® IDE och det har hänt lite sedan dess, vi håller på att uppdatera informationer kontinuerligt, men ibland hinner vi inte med. Våra instruktioner nedan förutsätter att man använder version 1.6.X av Arduino® IDE från Arduino CC, de äldre ser lite annorlunda ut, så ladda hem det senaste, man kan alltid ha kvar de äldre versionerna utan att de stör varandra.
Börja med att ladda hem Arduino® IDE som ni hittar här och följ de instruktioner för det operativsystem ni använder. Vi kommer här endast visa hur det fungerar för Windows. Ladda hem zip filen för Windows och packa upp den i t.ex. “C:\Arduino\” (du behöver ca 400Mb ledigt diskutrymme). Det går även att Köra Installer versionen för Windows, men vi föredrar zip-filen, för då kan man packa upp dem i olika mappar och ha kvar äldre versioner. Efter att du packat upp den i t.ex. “C:\Arduino\arduino-1.6.7\” katalogen (man kan givetvis flytta alla filer senare till en katalog som man föredrar). Det finns inte någon traditionell installationsfil i zip-filen utan det går att köra direkt i denna katalogen, vi rekommenderar att man skapar en genväg på skrivbordet (se bilden nedan) som länkar till filen “arduino.exe” och namnger genvägen t.ex. “Arduino 1.6.7”, så du lätt kan starta Arduino IDE och även veta vilken version det är. Vi har flera versioner installerade och kan således ge lite support beroende på vilken man kör.
Sedan skall USB drivrutiner installeras
Följande gäller med kort baserade på CH340 USB krets:
Viktigt att installera USB drivrutiner innan man ansluter kretskortet!
Kolla denna sida för installation av USB drivrutiner för ATMega328P R3 kort med CH340.
Hoppa sedan över nästa stycke om du har ett kort med CH340, fortsätt vid “Kontroll av hårdvaran…”
Följande gäller med Arduino® Uno R3 original med 16U2 USB krets:
Nu när detta är gjort skall man installera USB drivrutinerna till Arduinokortet, de finns i “C:\Arduino\arduino-1.6.7\drivers” katalogen om man använder de nya Arduino Uno korten, de äldre använder en annan USB krets från FTDI och då finns de i den underkatalogen. Koppla in Arduino Uno kortet med USB kabeln och Windows informerar om att det finns ny hårdvara samtidigt som den gröna lysdioden (ON) indikerar att kortet har fått spänning (5V OK), om kortet inte använts innan kommer även den gula lysdioden (L) att blinka.
Windows hittar normalt Arduino Uno drivrutinerna per automatik, så det är normalt inte några problem. Skulle det inte fungera får man uppdatera dem manuellt som bilderna nedan visar (fungerar olika beroende på den Windows version man kör). Våra bilder/instruktioner nedan visar Windows 7. Om drivrutiner inte kan installeras, gå till Enhetshanteraren och högerklicka på det som finns under “Andra enheter” som utropstecken med texten “Okända enhet” och välj att uppdatera drivrutinerna som bilden nedan visar.
Informera datorn (med andra alternativet “Välj drivrutinsprogramvara som redan finns på datorn”) om att du själv vet var de finns som på bilden nedan.
Leta upp katalogen genom att trycka på bläddra och sök dig fram till mappen och bekräfta när du hittat mappen “C:\Arduino\arduino-1.6.7\drivers” eller på det ställe du packat upp Arduino paketet. Avsluta med “Nästa”. Observera att bilden och texten nedan visar sökvägen till en mycket tidigare version från Arduino IDE (version 1.0), vi använder fortfarande dessa då om det är ett drivrutinproblem så fungerar det på samma sätt, bara ändra sökvägen till drivrutinerna!
Windows kan komma att varna för att drivrutinen inte är signerade, acceptera bara detta genom att trycka på “Installera drvrutin ändå” och efter detta kommer drivrutinerna för USB att installeras.
När drivruter installerats (kan ta tid), så skall det se ut så här som bilden nedan visar. Här ser man att det är ett Arduino Uno R3 som installerats samt i man ser redan här vilken COMport den tilldelats (COM10 i vårt fall).
När det väl är klart kommer Arduinokortet att finnas under “Portar (COM och LPT). Notera gärna vilken COMport den har blivit tilldelad. Om du redan installerat ett Arduino Uno kort innan på datorn kommer drivrutiner att installeras automatiskt och kortet tilldelas en COMport. Bilden nedan visar hur det kan se ut, i detta fallet har Arduinokotet tilldelats COM10.
Kör man i MacOS eller under Linux finns drivrutiner redan i operativsystemet så man behöver inte installera några där. Det skall även fungera bra numera från Windows 8.
Kontroll av att Arduinokortet och USB drivrutiner fungerar
Nu skall vi kontrollera om Arduino/Genuino Uno kortet har kontakt med Arduino Editorn, så starta Arduino IDE (arduino.exe) och då visas ett s.k. “Splash-fönster” och programmet laddas, det kan komma upp varningar första gången man startar programmet i Windows, det är bara att acceptera dem och även acceptera Javan.
När det startat välj “Tools” ur menyn och “Board” och se till att “Arduino/Genuino Uno” är valt som bilden nedan visar. Det är viktigt att man använder rätt inställning för vilken hårdvara man använder.
Sedan skall vi välja var Arduinokortet är anslutet och det gör vi ur samma “Tools” meny fast under “Serial Port”, välj den COMport som du noterade ned innan vid installationen av Arduinokortet. I vårt fall var det COM10.
Efter att detta är gjort öppnar vi ett enkelt demoprogram som följer med som blinkar med den gula lysdiod som sitter på kortet. Välj “File->Examples->01.Basic->Blink” och källkoden öppnas i ett nytt fönster (man kan stänga det första efter detta så slipper man ha det på skärmen). Bilden nedan visar var exempelkoden finns.
Programmet behöver nu kompileras och översättas till maskinkod samt laddas upp till Arduino/Genuino Uno, det gör man med andra knappen i toolbaren (pilen med ledtexten “Upload” när musen svävar över knappen), när detta är klart och det inte finns några fel kommer koden att laddas upp till kortet. Vill man bara verifiera koden trycker man på bocken i toolbaren, då kompileras endast koden utan att laddas upp till kortet.
Då detta är ett litet program kommer det gå ganska snabbt att ladda upp, man kan se att lysdioderna märkta TX och RX blinkar till lite (dessa lysdioder visar kommunikationen mellan datorn/kortet) och efter att programmet är överfört så kör det igång automatiskt, man kan nu se att den gula lysdioden (L) blinkar, den är tänd 1s och släckt 1s. Texten “Done uploading.” visas i Arduino IDE under editorn. Under detta statusfönster finns ett svart fält, där ser man vad som händer i bakgrunden, själva kompileringen m.m. och under detta ser man vilket kort man har och på vilken port den är ansluten.
Gratulerar, nu har du kompilerat ditt första program och laddat upp det till Arduino/Genuino Uno. Skulle det inte fungera får man felsöka på Arduino sidan och i deras Forum. Där finns en speciell diskussionsgrupp för installation och felsökning.
Låt oss se lite vad programmet (på Arduino språk heter programmet “Sketch”) gör och hur det är uppbyggt, de första fyra raderna är s.k. kommentarer och är till för att programmeraren/användaren skall kunna göra noteringar i koden, dessa ignoreras helt av kompilatorn. Kommentar som sträcker sig över flera rader börjar med /* och avslutas med */, där i mellan kan man skriva precis vad som helst.
/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.
Most Arduinos have an on-board LED you can control. On the Uno and
Leonardo, it is attached to digital pin 13. If you're unsure what
pin the on-board LED is connected to on your Arduino model, check
the documentation at http://www.arduino.cc
This example code is in the public domain.
modified 8 May 2014
by Scott Fitzgerald
*/
Rutinen setup() är det som anropas först när ett program startas i ett Arduinoprogram, men innan detta händer körs annan initial kod som du som programmerare inte ser i ditt program, det kan vara att ställa in variabler, interrupt och mycket mer som är unikt för den microcontroller du använder. Denna rutin returnerar inte något, det ser vi med texten void före. I setup() ställer vi in alla parametrar, IO etc. som skall ställas in varje gång programmet startas. Rutinens start visas med { och avslutas med }. Notera att varje funktion/kommando avslutas med ett semikolon “;”. Det vi gör i detta exemplet är att se till att IO pinnen 13 skall vara en utgång och det är ju där vi har lysdioden ansluten.
// the setup function runs once when you press reset or power the board void setup() { // initialize the digital pin 13 as an output. pinMode(13, OUTPUT); }
Rutinen loop() returnerar heller inget, den är av typen void. Här är själva huvudslingan av ditt program och här snurrar programmet hela tiden tills man trycker på reset, laddar ner ny kod eller spänningen försvinner. Samma sak här, det innesluts av { }. Det första funktionen är digitalWrite() och den tar två parametrar, först är IO pinnen vi vill använda, den andra är vilken nivå vi vill att denna IO pinne skall anta, HIGH (Hög, logisk etta eller i vårt fall +5V). Nästa rad är en funktion som heter delay() och tar en parameter och den parametern är en fördröjning i millisekunder (mS), i detta fallet 1000mS = 1S. Sedan tredje raden ändrar vi återigen vilken nivå IO pinne 13 skall ha och i detta fallet LOW (Låg, logisk nolla eller i vårt fall 0V/GND), slutligen en fördröjning på 1000mS igen. Efter detta hoppar den upp till första raden igen då detta är en loop som aldrig slutar. Som ni ser finns det dubbla // efter avslutande funktions semikolon, detta är en så kallad enradskommentar och här kan man skriva hjälptext och kommentaren tar slut vid radmatning.
// the loop function runs over and over again forever void loop() { digitalWrite(13, HIGH); // set the LED on delay(1000); // wait for a second digitalWrite(13, LOW); // set the LED off delay(1000); // wait for a second }
På nästa sida skall vi koppla in en extern lysdiod som blinkar med samma program som vi precis kompilerat och laddat upp. Den interna gula lysdioden sitter på I/O pinne 13.
Uppdaterad den 30 augusti 2018