Tilbake
4.5
Mikrokontrollere og Arduino

4.5 Mikrokontrollere og Arduino

Arduino-plattformen, oppbygning og grunnleggende bruk.

35 min
5 oppgaver
ArduinoMikrokontrollerDigitale pinnerAnaloge pinner
Du leser den tradisjonelle versjonen
Din fremgang i kapitlet
0 / 5 oppgaver

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.

Mikrokontroller

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!

Arduino
Arduino er en åpen kildekode-plattform for elektronikk og programmering. Plattformen består av:

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

✏️Eksempel: Oppbygningen av Arduino Uno

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

📝Oppgave 1

Hva inneholder IKKE en mikrokontroller?

Digitale pinner
Digitale pinner på Arduino kan ha to tilstander:

- 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 INPUT
PULLUP
- digitalWrite(pin, value) – Skriver HIGH eller LOW til en utgangs-pinne
- digitalRead(pin) – Leser tilstanden (HIGH eller LOW) fra en inngangs-pinne

Analoge pinner
Analoge innganger (A0–A5) bruker en analog-til-digital-omformer (ADC) for å lese spenninger mellom 0 V og 5 V.

ADC-en har 10-bits oppløsning, som betyr:
- 0 V → verdien 0
- 5 V → verdien 1023
- Oppløsning: 5,0 V10244,9 mV\displaystyle \frac{5{,}0 \text{ V}}{1024} \approx 4{,}9 \text{ mV} per steg

Funksjon:
- analogRead(pin) – Returnerer en heltallsverdi fra 0 til 1023

Eksempel: Hvis en sensor gir 2,5 V, leser Arduino:
verdi=2,55,0×1023512\text{verdi} = \frac{2{,}5}{5{,}0} \times 1023 \approx 512

Merk: Arduino Uno har ikke en ekte analog utgang. Funksjonen analogWrite() bruker i stedet PWM (pulsbreddemodulasjon) på de digitale pinnene merket med ~.

✏️Eksempel: Blink – ditt første Arduino-program

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.

📝Oppgave 2

I et Arduino-program kjøres setup()-funksjonen:

✏️Eksempel: Styre LED med knapp

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)

📝Oppgave 3

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.

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!

📝Oppgave 4

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).

📝Oppgave 5

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.