Arduino-plattformen, oppbygning og grunnleggende bruk.
Mikrokontrollere og Arduino
Hittil har vi jobbet med passive og aktive elektroniske komponenter, men vi har styrt kretsene manuelt – med brytere, potensiometre og faste koblinger. Nå skal vi ta det store steget: å bruke en mikrokontroller til å styre elektronikken med programkode.
En mikrokontroller er en liten datamaskin på én eneste brikke. Den kan lese signaler fra sensorer, ta beslutninger basert på programmet vi skriver, og styre aktuatorer som lys, motorer og høyttalere. Den mest populære plattformen for læring og prototyping er Arduino.
I dette kapittelet lærer du hva en mikrokontroller er, hvordan Arduino-plattformen er bygd opp, og hvordan du skriver og laster opp ditt første program.
En mikrokontroller (forkortet MCU – Microcontroller Unit) er en liten, integrert datamaskin på én enkelt brikke. Den inneholder:
- Prosessor (CPU): Utfører instruksjoner fra programmet
- Flash-minne: Lagrer programmet (beholdes når strømmen er av)
- RAM: Midlertidig arbeidsminne for data under kjøring
- I/O-pinner: Digitale og analoge inn- og utganger for kommunikasjon med omverdenen
- Klokke: Styrer hastigheten på prosessoren (typisk 8–16 MHz for Arduino)
Til forskjell fra en vanlig datamaskin er en mikrokontroller designet for å kjøre ett enkelt program i en uendelig løkke, og den har svært begrenset minne og prosessorkraft – men den er billig, liten og energieffektiv.
Mikrokontrollere i hverdagen
Du er omgitt av mikrokontrollere uten å tenke over det. De finnes i:
- Hvitevarer: Vaskemaskin, oppvaskmaskin, mikrobølgeovn
- Transport: Bilens motorstyring, ABS-bremser, airbag
- Underholdning: Fjernkontroller, spillkontrollere, LED-strips
- Helse: Digitale termometre, blodtrykksmålere, insulinpumper
- Hjemmeautomatisering: Smarte lyspærer, termostat, dørlåser
En moderne bil kan inneholde over 100 mikrokontrollere som samarbeider!
1. Maskinvare: Et utviklingskort med en mikrokontroller (vanligvis ATmega328P), USB-tilkobling, spenningsregulator og tilgjengelige pinner.
2. Programvare (IDE): Et gratis utviklingsmiljø der du skriver kode, kompilerer og laster opp til kortet via USB.
3. Programmeringsspråk: Basert på C/C++ med forenklede funksjoner for å styre maskinvaren.
Det mest brukte kortet for nybegynnere er Arduino Uno, som har:
- 14 digitale I/O-pinner (hvorav 6 støtter PWM)
- 6 analoge innganger (A0–A5)
- 5 V driftsspenning
- USB-tilkobling for programmering og strømforsyning
- 32 KB flash-minne for programmet
Beskriv de viktigste delene på et Arduino Uno-kort og hva de brukes til.
Et Arduino Uno-kort har følgende hoveddeler:
Strøm og tilkobling:
- USB-port: Kobles til PC for programmering og kan gi 5 V strøm
- Ekstern strøminngang (barrel jack): 7–12 V DC for frittstående drift
- 5 V og 3.3 V utganger: Gir regulert spenning til eksterne komponenter
- GND-pinner: Jordtilkobling (referansepunkt for spenning)
Digitale pinner (0–13):
- Kan settes som INPUT (lese) eller OUTPUT (skrive)
- Opererer med to nivåer: HIGH (5 V) og LOW (0 V)
- Pinne 0 og 1 brukes også til seriell kommunikasjon (TX/RX)
- Pinne merket med ~ (3, 5, 6, 9, 10, 11) støtter PWM-utgang
Analoge pinner (A0–A5):
- Leser analoge spenninger fra 0 til 5 V
- Konverterer til digitalverdi mellom 0 og 1023 (10-bits oppløsning)
- Kan også brukes som digitale pinner ved behov
Mikrokontrolleren (ATmega328P):
- Selve «hjernen» – kjører programmet ditt
- 16 MHz klokkefrekvens, 32 KB flash, 2 KB RAM
Hva inneholder IKKE en mikrokontroller?
- HIGH = 5 V (logisk 1)
- LOW = 0 V (logisk 0)
Pinnene kan konfigureres som:
- OUTPUT: Arduino sender et signal ut (f.eks. tenne en LED)
- INPUT: Arduino leser et signal inn (f.eks. lese en knapp)
- INPUTPULLUP: Som INPUT, men med en innebygd pull-up-motstand som holder pinnen HIGH når ingenting er tilkoblet
Funksjoner for digitale pinner:
- pinMode(pin, mode) – Setter pinnen som INPUT, OUTPUT eller INPUTPULLUP
- digitalWrite(pin, value) – Skriver HIGH eller LOW til en utgangs-pinne
- digitalRead(pin) – Leser tilstanden (HIGH eller LOW) fra en inngangs-pinne
ADC-en har 10-bits oppløsning, som betyr:
- 0 V → verdien 0
- 5 V → verdien 1023
- Oppløsning: per steg
Funksjon:
- analogRead(pin) – Returnerer en heltallsverdi fra 0 til 1023
Eksempel: Hvis en sensor gir 2,5 V, leser Arduino:
Merk: Arduino Uno har ikke en ekte analog utgang. Funksjonen analogWrite() bruker i stedet PWM (pulsbreddemodulasjon) på de digitale pinnene merket med ~.
Skriv et program som blinker den innebygde LED-en (pinne 13) på Arduino-kortet: 1 sekund på, 1 sekund av.
Her er det klassiske «Blink»-programmet som alle Arduino-nybegynnere starter med:
// Blink – Ditt første Arduino-program
// Blinker den innebygde LED-en på pinne 13
void setup() {
// setup() kjøres én gang ved oppstart
pinMode(13, OUTPUT); // Sett pinne 13 som utgang
}
void loop() {
// loop() kjøres om og om igjen, i det uendelige
digitalWrite(13, HIGH); // Tenn LED-en (5 V)
delay(1000); // Vent 1000 ms = 1 sekund
digitalWrite(13, LOW); // Slukk LED-en (0 V)
delay(1000); // Vent 1 sekund
}Forklaring av programstrukturen:
- setup(): Kjøres én gang ved oppstart. Her initialiserer vi pinner og innstillinger.
- loop(): Kjøres i en uendelig løkke etter setup(). Her legger vi hoveddelen av programmet.
- pinMode(13, OUTPUT): Konfigurerer pinne 13 som utgang.
- digitalWrite(13, HIGH): Setter pinne 13 til 5 V (LED lyser).
- delay(1000): Pauser programmet i 1000 millisekunder (1 sekund).
Resultatet: LED-en blinker med 0,5 Hz – én gang per 2 sekunder.
I et Arduino-program kjøres setup()-funksjonen:
Skriv et program som leser en trykkknapp koblet til pinne 2 (med innebygd pull-up-motstand) og tenner LED-en på pinne 13 når knappen er trykket ned.
// Knapp-styrt LED
// Knapp på pinne 2 (INPUT_PULLUP), LED på pinne 13
void setup() {
pinMode(13, OUTPUT); // LED som utgang
pinMode(2, INPUT_PULLUP); // Knapp med innebygd pull-up
}
void loop() {
int knappStatus = digitalRead(2); // Les knappen
if (knappStatus == LOW) {
// LOW betyr at knappen er trykket (pull-up inverterer logikken)
digitalWrite(13, HIGH); // Tenn LED
} else {
digitalWrite(13, LOW); // Slukk LED
}
}Viktige detaljer:
- Med INPUT_PULLUP er pinnen HIGH (5 V) når knappen ikke er trykket.
- Når knappen trykkes, kobles pinnen til GND, og den blir LOW (0 V).
- Derfor er logikken invertert: LOW = knappen er trykket.
Kobling:
- Knapp: Én side til pinne 2, andre side til GND
- Ingen ekstern motstand nødvendig (den innebygde pull-up-motstanden tar seg av det)
Arduino Uno har 6 analoge innganger med 10-bits oppløsning. Hvor mange ulike verdier kan analogRead() returnere?
Seriell kommunikasjon – se hva Arduino-en «tenker»
En viktig funksjon for feilsøking og datalogging er seriell kommunikasjon. Arduino kan sende tekst og tall til PC-en via USB-kabelen, som du kan lese i Serial Monitor i Arduino IDE.
void setup() {
Serial.begin(9600); // Start seriell kommunikasjon med 9600 baud
Serial.println("Arduino klar!");
}
void loop() {
int sensorVerdi = analogRead(A0); // Les analog sensor
Serial.print("Sensorverdi: ");
Serial.println(sensorVerdi); // Skriv verdien til PC
delay(500); // Vent 0,5 sekunder
}- Serial.begin(9600): Starter kommunikasjonen med en hastighet på 9600 baud (bits per sekund).
- Serial.print(): Skriver tekst uten linjeskift etter.
- Serial.println(): Skriver tekst med linjeskift etter.
Seriell Monitor er uvurderlig for å forstå hva programmet gjør, og for å lese sensordata i sanntid.
1. Bruk alltid forresistans med LED-er – kobler du en LED direkte til 5 V uten motstand, kan du ødelegge LED-en og Arduino-pinnen.
2. Ikke trekk mer enn 20 mA fra én pinne – total maks for alle pinner er 200 mA.
3. Koble aldri spenning over 5 V til en pinne – dette kan ødelegge mikrokontrolleren.
4. Koble fra strøm før du endrer koblinger – spesielt med motorer og reléer.
5. Bruk breadboard – det gjør det enkelt å eksperimentere uten å lodde.
6. Sjekk koblingene nøye – en kortslutning kan ødelegge kortet permanent.
Oppsummering – Mikrokontrollere og Arduino
Mikrokontroller:
- Liten datamaskin på én brikke (CPU, minne, I/O)
- Kjører ett program i en uendelig løkke
- Finnes overalt i moderne teknologi
Arduino-plattformen:
- Åpen kildekode maskinvare og programvare
- Arduino Uno: 14 digitale pinner, 6 analoge innganger, 5 V, USB
- Programmeres i C/C++ via Arduino IDE
Programstruktur:
- setup() kjøres én gang ved start
- loop() kjøres i uendelig løkke
- pinMode(), digitalWrite(), digitalRead(), analogRead()
Digitale pinner: HIGH (5 V) eller LOW (0 V) – to tilstander
Analoge innganger: 0–1023 (10-bits ADC) – måler spenning 0–5 V
Seriell kommunikasjon: Send data til PC for feilsøking og datalogging
I neste kapittel skal vi koble sensorer til Arduino-en og begynne å måle den virkelige verden!
Du vil lage et «trafikklys» med tre LED-er (rød på pinne 8, gul på pinne 9, grønn på pinne 10). Skriv et Arduino-program som gjennomfører en trafikklys-syklus: grønt i 5 sekunder → gult i 2 sekunder → rødt i 5 sekunder → rødt og gult sammen i 1 sekund → grønt igjen (og så videre i loop).
Forklar med egne ord forskjellen mellom digitale og analoge pinner på Arduino. Gi et eksempel på en komponent du ville koblet til hver type pinne, og forklar hvorfor.
Dette kapitlet er skrevet av Anthropics toppmodeller (Claude Opus og Claude Fable) og er foreløpig ikke manuelt gjennomgått — kvalitetskontrollen gjøres av uavhengige KI-agenter, og innmeldte feil rettes fortløpende. Funnet en feil? Meld fra, så retter vi den. Les mer om hvordan innholdet lages.