För några år sedan träffade jag en student från Malmö högskola, vi pratade lite allmänt om teknik och när jag berättade att jag pysslade med hembränd elektronik blev han intresserad och började prata om något som kallades för Arduino. Hans intresse var mjukvara och han berättade om programmering och då speciellt hur de i sina laborationer använde ett labbkort och en utvecklingsmiljö som kunde användas för hobbyändamål. Mjukvara och programmering var något som jag just då inte var speciellt intresserad av, men på något sätt sorterade jag in informationen i arkivet. Lite senare behövde jag en timer där jag kunde laborera med ingångar, utgångar och tider, då kom jag ihåg en del av vad han berättat. Sagt och gjort, ett besök på Electrokits hemsida resulterade i att det låg ett Arduino-kort i postlådan ett par dagar senare. På den vägen är det, nu några år senare har Arduino en given plats på min labbänk. Den kommer till användning då och då, antingen när jag behöver någon speciell funktion eller om jag har läst någon artikel som handlar om något trevligt projekt som man kan laborera lite med. I denna artikel tänkte jag dela med mig lite av vad jag har lärt mig så här långt och förhoppningsvis hjälpa dig som är lite intresserad att ta steget, visa vägen in i ett nytt område att utforska.

 

Vad är då Arduino?

Man kan se Arduino som en plattform för experiment men som även kan användas som en del i en hembyggd apparat. Konceptet (systemet) består av en standardiserad hårdvara i form av ett kort med en mikrokontroller, ett grunddefinierat utökningskort/shield) en bootloader (startmjukvara i mikrokontrollern), ett programspråk och en PC-applikation som är själva utvecklingsmiljön. Det intressanta är att det mesta kring Arduino är s.k. open source, inte bara mjukvaran utan också hårdvaran, alla scheman och kortlayouter finns
tillgängliga på nätet. För den hugade är det bara att ladda ner och börja experimentera. För min del har det fungerat utmärkt med standardkorten och en påse labb-komponenter, just nu ligger det en Arduino Uno på bänken där jag har labbat fram en rotorstyrning.

Hårdvara

Av praktiska skäl begränsar jag fortsättningsvis alla beskrivningar här till Arduino Uno som är den vanligaste versionen just nu (januari 2012).

Arduino Uno R2 är byggd kring en mikrokontroller från Atmel i deras AVR familj med beteckningen ATMEGA328. Det finns en DC anslutning (7-12 V), 5 V- och 3,3 V- regulatorer, en ICSP-port för direktkommunikation med mikrokontrollern, en USB-port, ett antal lysdioder, reset- knapp och det kanske viktigaste: ett antal in- och utgångar (I/O). Förutom att vara anpassning till PC kan USB-porten strömförsörja kortet, detta är väldigt praktiskt om man vill laborera med mjukvaran till sitt bygge på bussen med sin laptop eller för den delen i tv-soffan.

I/O-pinnarna är distribuerade så här: 14 st digitala varav 6 st kan konfigureras för PWM. Varje I/O kan hantera 40 mA och man bestämmer enkelt i programmet om de är in- eller utgång. Det finns även 6 st analoga ingångar, som standard kan dessa läsa 0-5 V och presentera värdet med 10 bitars upplösning (1024 steg).

Förutom dessa I/O-möjligheter finns några ytterligare pinnar och funktioner men jag väljer här att hänvisa till Arduinos hemsida, http://www.arduino.cc, för att hålla denna artikel rimligt kort.

Bootloader

En av de viktigaste delarna som gör Arduino-konceptet enkelt och användarvänligt är bootloadern. Kort beskrivet är bootloadern ett litet program som körs några sekunder efter uppstart och som öppnar processorn för att ladda upp program direkt via den vanliga USB-porten. När tiden gått ut startar bootloadern det uppladdade programmet. Man behöver inte starta om kortet manuellt för att ladda upp nytt program, det sker automatiskt från utvecklingsmiljön.

När bootloadern startar så blinkar den med lysdiod (L) som är ansluten till pinne 13 på kortet. Det är en bra indikator att använda när man felsöker.

Programspråk

Arduino har ett eget programspråk som bygger på C/C++. En stor fördel med detta är att det finns väldigt många aktiva programmerare att fråga om hjälp. Det märks på Internet- forumen där olika lösningar diskuteras, ofta kan någon utan direkt Arduino-erfarenhet hoppa in och ge tips.

Utvecklingsmiljö

Den fjärde systemkomponenten är utvecklingsmiljön som enkelt uttryckt är PC programmet man använder för att skriva program och sen ladda upp det till sitt Arduino-kort. I själva verket är denna miljön väldigt komplex och det har lagts mycket tid på att anpassa detta paket så att det kan användas och förstås av alla från rena nybörjare till mera avancerad utvecklare.

Utökningskort (shields)

En väldigt smart sak i konceptet är idén med s.k. shields. Hårdvaruutvecklarna har standardiserat kortets formfaktor och placering av pinnarna för I/O och strömförsörjning. Till detta har de tagit fram ett i princip tomt labb-kort (protoshield) där man kan bygga på sin egen konstruktion á la veroboard. Tack vare att layouten är open source och allmänt tillgängligt är det då möjligt att skapa sin egen shield med specifika konstruktioner och optimerad layout. Det finns säkert hundratals olika shields med ett stort urval av kretsar tillgängliga idag och fler tillkommer i rask takt. Nu är man inte på något sätt begränsad till att använda shields för att bygga sina konstruktioner, jag har använt både vanliga veroboards, rena luftbyggen modell kråkbo och s.k. breakout- kort med olika komponenter som finns i en uppsjö från olika tillverkare.

Labbkit

Över tid har jag byggt upp ett litet sortiment med “bra att ha”-prylar i vad man skulle kunna kalla ett labbkit. Det består av diverse komponenter som jag har lött fast på den där typen av testsladdar man använder när man bygger på s.k. breadboards. De gör experimenterandet smidigt. Testsladdar, potentiometer, lysdioder i olika färger, touchpanel, displayer, sensorer och omkopplare är exempel på vad som finns i lådan.



Hur kommer man igång?

Kruxet med att använda mikrokontrollers är inte att installera utvecklingsmiljön och koppla upp alla delarna, den delen är väldigt välbeskriven på hemsidan så för den delen hänvisar jag dit, http://www.arduino.cc, utan det man behöver lära sig är att först för sig själv beskriva exakt vad det är man vill göra, sen med hjälp av specifikationer och referenser för Arduino och kringkomponenter göra en systembild som beskriver funktionen i detalj. Därefter kan man börja skapa hårdvaran och sen kommer man till programmeringen. Om man lägger upp sitt projekt på detta sätt har man hårdvaran tillgänglig när man börjar laborera med programmeringen, för min del är det programmeringen som tar mest tid och tankemöda och då känns det bra att inte samtidigt behöva meka med hårdvaran.

Låt oss ta ett enkelt exempel, för ett kommande projekt vill jag lära mig hur man läser av värdet på en potentiometer med hjälp av de analoga ingångarna. För att göra det enkelt när man utvecklar finns det en funktion i PC-programmet som heter serial monitor. I detta exempel vill jag använda den för att presentera värdet på potentiometern.

Systemet kommer då att bestå av följande delar:
PC med Arduino utvecklingsmiljö Arduino Uno kopplad via USB till PC:n Potentiometer kopplad till Arduino Uno

Då är det ett par funktioner som måste lösas i programmet, och det är här detektivarbetet börjar. Eftersom det finns många som jobbar med Arduino och att utvecklarteamet har velat göra det användarvänligt finns det mycket “färdiga” funktioner man kan använda. Dessa finns inbakade som kommandon eller finns tillgängliga i externa bibliotek som man inkluderar i sin kod.

I detta fall vill vi skicka värdet från potentiometern till serieporten, en snabb sökning på referenssidan visar att det finns ett färdigt kommando för att “starta” denna funktion:

Serial.begin(9600);

Sen behöver vi ju något att skicka dit och tanken var ju att läsa av en potentiometer. Det gör man enklast i tre steg

1, bestäm variabeltyp och ge den ett namn
2, läs av värdet på Analog in Pinne 0 (A0)
3, spara värdet i variabeln.

int sensorValue = analogRead(A0);

Nu kommer processorn att spara värdet från potentiometern kontinuerligt. För att skriva ut värdet till serieporten säger vi åt processorn att kontinuerligt skriva ut variabeln sensorValue till serieporten. Kom ihåg att vi redan “startat” möjligheten att kunna skriva till serieporten.

Serial.println(sensorValue);

Då har vi skapat programmet som består av tre rader kod

Serial.begin(9600);

int sensorValue = analogRead(A0); Serial.println(sensorValue);

Nästa steg är att skapa det som kallas “sketch” på Arduino- språk. För att vårt lilla program skall fungera måste det skapas maskinkod innan det laddas upp till vårt Uno-kort. Detta är en procedur som kräver att vår programkod är skriven på ett strikt sätt enligt ett regelverk, utan att gå in på detaljerna och göra anspråk på att vara en komplett beskrivning så sker det i princip två saker: först länkas koden med fördefinierad kod som finns i olika bibliotek, sen kompileras all kod till maskinspråk. Därför kommer resultatet att se ut så här.

void setup() { Serial.begin(9600);
}

void loop() {
int sensorValue = analogRead(A0); Serial.println(sensorValue);
}

Som synes består programmet av två delar, setup används för sådant som bara behöver göras en gång vid uppstart, i detta fallet “starta” serieporten. Loop är själva huvudprogrammet som läser potentiometern, sparar variabeln och skriver den till serieporten.

Ovanstående exempel har jag lånat från Arduinos hemsida där det finns en uppsjö av väl beskriven kod och kopplingsexempel som man kan klippa och klistra in i sitt eget projekt. En sak de har gjort speciellt bra är att de flesta exemplen hänger ihop, exempelvis används ovanstående exempel när de sen beskriver hur man reglerar en lysdiod med potentiometern.

Naturligtvis finns det mera att gräva i om man vill analysera detta tillsynes enkla program, exempelvis varför används variabeltypen “int” och hur kommer spänningen från potentiometern att presenteras på PC skärmen? Men det lämnar jag som hemläxa till dig att forska vidare i.

Som alltid finns det genvägar eftersom Arduino mer eller mindre har blivit en hobby i sig för många experimenterande amatörer som gärna delar med sig av sina alster. Så finns det många hemsidor på nätet med alla möjliga och omöjliga projekt där alla scheman och programsketcher finns att ladda ner. Jag ser inget fel i att använda sådan kod, men jag brukar i varje fall bemöda mig om att sätta mig in i hur programmet fungerar och om jag använder det skickar jag minst ett mejl till skaparen och tackar för att denne delar med sig.

Ett amatörradioprojekt med Arduino

Många av våra apparater och projekt innehåller något man måste vrida på, det spelar ingen roll om det är en omkopplare, potentiometer, vridkondensator eller rullspole. Låt oss ta ett aktuellt exempel från diskussioner som pågår just nu på våra Ham-forum, vi behöver en funktion som hjälper oss att vrida på en vridkondensator till en antennavstämning och där man kan bygga vidare med fjärrstyrning och automatisk avstämning.

Då kan man fråga sig hur man kan automatisera just denna funktion att vrida på något. Kan man använda Arduino på något sätt?

Nu börjar det kreativa arbetet, till en början är det en helt teoretisk övning där jag börjar med att rita en skiss mitt på ett stort papper och skriva ett par ord som visar ganska exakt vad jag vill åstadkomma. Detta hjälper mig sen att inte bli för “kreativ” och lägga till för mycket i mitt projekt.

Steg 2

Nu kommer nästa fas i projektet, jag har redan antagit att det är Arduino jag vill använda så nu är det dags att besöka Arduinos hemsida och gräva i dokumentationen. För min egen del brukar jag börja med den del som kallas “tutorials”, där finns många praktiska exempel och redan där hittar vi exempel som kan användas i detta projekt.

Det finns möjlighet att avläsa analoga värden 0-5 V, värdet omvandlas till ett värde mellan 0 och 1023. Det finns möjlighet att styra motorer, eftersom jag råkar ha ett antal RC-servon i junkboxen väljer jag att gå vidare med ett sådant. Just det har ett arbetsområde på 180 grader som helt enkelt bestäms i skalan 0-179 i Arduino.

 

 

Nu kommer vi till ett problem som måste lösas. Eftersom vi har olika skalor på in- och utgång måste vi finna ett sätt att omvandla från 0-1023 till 0-179. Denna gång väljer jag att konsultera “References”, det jag letar efter är om det finns någon färdig funktion som kan lösa mitt problem med att skala om värden. Återigen har jag tur, någon har haft liknande behov och det finns en färdig funktion för detta, (map()), som helt enkelt mappar om ett område till ett annat.

Slutsatsen blir att, jodå det verkar möjligt att bygga detta med Arduino. NU är det dags för det riktigt roliga, att experimentera. Detta brukar jag göra i två delar, först samla ihop komponenter ur junkboxen, skissa ett schema och sen sätta mig i soffan och programmera. Men först brukar jag leta efter exempel på hur andra har löst liknande problem. I detta fall har jag redan hittat ett exempel bland “tutorials” som jag använder som referens.

Hårdvara

Arduino Uno
10k potentiometer
RC-servo

Not: För att hålla fokus på Arduino och hur man kommer igång med programmering har jag inte tagit hänsyn till att det i verkligheten troligen kommer att krävas avkopplingar och filtreringar.

Mjukvara

Eftersom vi vet ganska väl vad vi vill göra och hur vi har kopplat in våra komponenter till Arduino så gäller det nu att få ihop detta så att utvecklingsmiljön kan hantera vår kod. Jag gör detta direkt i Arduino PC-programmet.

Vi börjar från början, detta är absolut det minsta man måste ha med i ett Arduino-program.

void setup() {
// stoppa in uppstartskod här, körs en gång vid uppstart:

}

void loop() {
// skriv din huvudkod här, körs kontinuerligt:

}

Detta kan vi testa genom att klicka på funktionen “verify”, då kommer vi automatiskt att få en felkontroll och om något är fel så får vi veta det direkt. Ett tips är att spara ofta, jag brukar döpa mitt projekt när jag kommit så här långt och sen spara med nytt versionsnummer varje gång jag fått OK när jag har använt “verify”, i detta fallet blir det vridkondensator_01.pde.

Vi börjar med potentiometern, den är ju inkopplad så att mittstiftet kommer att lägga variabel spänning på Arduino- pinne A0. Det måste vi berätta för programmet, vidare måste vi också berätta vad det är för typ av data som vi läser (0-
1023) Utan att gå in på detaljer konstaterar jag att lämplig datatyp är integer som förkortas ”int”. Detta värde måste också spara i minnet och det görs genom att vi ger det ett namn eller variabel, i detta fallet kallar jag det ”pot”. Detta kallas att deklarera något och det lägger man in före uppstartskoden.

int potpin = 0;
int pot;

void setup() {
// stoppa in uppstartskod här, körs en gång vid uppstart:

}

void loop() {
// skriv din huvudkod här, körs kontinuerligt:

}

Potentiometern skall läsas kontinuerligt så det måste beskrivas i funktionen loop, helt enkelt en instruktion att kontinuerligt läsa värdet på potentiometern. Man kan experimentera lite genom att flytta upp denna rad till setup och se vad som händer.

int potpin = 0;
int pot;

void setup() {
// stoppa in uppstartskod här, körs en gång vid uppstart:

}

void loop() {

pot = analogRead(potpin);

}

Så var vi klara med potentiometern och det är dags att fundera lite på hur man kontrollerar ett servo. Detta är lite mera komplicerat men om man läser exemplet i “tutorials” lär vi oss att någon har varit vänlig nog att skapa ett “library” med kod som vi kan använda. Libraries eller lib som det förkortas gör programmeringen enklare och sparar en massa tid. Istället för att skriva om alla funktioner från början kan man i kommande projekt återanvända dessa libs. I detta fall finns det ett lib som heter Servo.h som innehåller alla funktioner för att kontrollera ett RC-servo så det tar vi med i vårt program genom att helt enkelt inkludera det. Eftersom Servo.h kan återanvändas flera gånger i samma program måste vi ge just vårt servo ett namn, jag väljer att kalla det för
”kond”. Precis som med potentiometern måste man bestämma vilken digital utgång på Arduino-kortet vi vill koppla in servot på, av någon anledning har den som skrev Servo.h valt en lite annorlunda metod här och vill att man gör det i setup-funktionen istället med attach.

Då är det bara en sak kvar för att styra servot och det är att se till att loop-funktionen kan styra servot kontinuerligt och det görs med ”write”. Ett servo är ju lite trögt och därför kan det vara lämpligt att ta med en liten fördröjning så att det hinner med att flytta sig, det gör man med ”delay”.

#include <Servo.h> Servo kond;

int potpin = 0;

int pot;

void setup() {

kond.attach(7);

}

void loop() {

pot = analogRead(potpin);
kond.write(pot);
delay (20);

}

Det sista som återstår är då att lösa mappningen mellan potentiometerns värde och servots position. I undersökningen tidigare hittade jag en funktion för detta, ”map” som kommer väl till pass. Nu gäller det att göra detta på rätt ställe i programmet, efter att potentiometervärdet är inläst och innan det skrivs till servot. Därför stoppar vi in en rad mitt emellan.

#include <Servo.h> Servo kond;
int potpin = 0;
int pot;

void setup() {

kond.attach(7);

}

void loop() {

pot = analogRead(potpin);
val = map(val, 0, 1023, 0, 179);
kond.write(pot);
delay (20);

}

Då var programmet klart och det är bara att klicka på upload så kommer det att verifieras och om allt är OK skickas upp till vårt Arduino-kort. Om vi allt är rätt kan vi testa genom att vrida på potentiometern och då skall servot följa med proportionellt. Detta kan man sedan vidareutveckla i många riktningar, lägga till SVF-mätning för att avstämma automatiskt, lägga till fler servon för att vrida en antenn, koppla in en display för att visa riktning och SVF, fjärrstyra från dator via USB-porten och så vidare.

Vad mer kan man göra?

Man brukar ju säga att det bara är fantasin som sätter gränser, men det finns ju naturligtvis begränsningar rent fysiskt med vad man kan göra. För amatörradiobruk kan jag tänka mig en massa saker. Med Arduino kan man mäta analoga signaler,
läsa och skriva digitala utgångar, programmera logiska funktioner och så vidare. Med Arduino kan man bygga en uppsjö olika amatörradiorelaterade projekt exempelvis.

Uteffekt-/SVF-mätare Styrning till tuner Rotorstyrning Signalgenerator Sequencer
Keyer Repeaterstyrning Antennswitch

Dokumenterade amatörradioprojekt

Jag har samlat på mig ett antal länkar med amatörradio- relaterade Arduino-projekt, tyvärr försvinner ju vissa sidor från nätet efter hand så man får betrakta dess länkar som färskvara. De är värdefulla på så sätt att man kan lära sig en hel del om hur man skall lösa problem med programmering genom att kika på hur andra har gjort. Naturligtvis kan man helt enkelt bara bygga ihop hårdvaran och använda programmet rakt av, men då har man ju missat en bra möjlighet att experimentera och lära sig något nytt.

Rotorstyrningar http://radioartisan.wordpress.com/yaesu-rotator-computer- serial-interface/

Signalgenerator http://www.theladderline.com/dds-60

CW keyer http://radioartisan.wordpress.com/arduino-cw-keyer/

CW transceiver http://www.theladderline.com/book/export/html/34

Band-/antennswitch http://www.qsl.net/on7eq/projects/arduino_ant_matrix.htm

APRS tracker http://9m2pju.blogspot.com/2011/06/arduino-aprs-avr-using- bertos.html

Tunerstyrning http://ernest.utreg.net/?page=arduino-tuner

SVF-/uteffektmeter http://www.qsl.net/on7eq/projects/arduino_pwr_swr.htm

Var hittar jag mer information?

Arduino har en alldeles utmärkt hemsida, http://www.arduino.cc, som är den naturliga startpunkten. Här finns alla referenser, guider och en massa exempel tillgängliga. Jag lovar att där finns många kvällars sysselsättning bara att gå igenom alla guider och lära sig grunderna. När du känner dig nöjd med den sajten så är det bara att googla vidare, eftersom det är så många över hela jordklotet som laborerar med Arduino finns det något nytt att hitta i princip varje dag.

@

----------------------------------Red. Anmärkning----------------------------------------------------

Även publicerad i ESR resonans 1 2012