Tilbake
4.8
Praktiske kretser og prosjekter

4.8 Praktiske kretser og prosjekter

Bygge komplette kretser med sensorer, aktuatorer og mikrokontroller.

35 min
5 oppgaver
KretskonstruksjonBreadboardProsjektFeilsøking
Du leser den tradisjonelle versjonen
Din fremgang i kapitlet
0 / 5 oppgaver

Prosjektarbeid med elektronikk

I de foregående kapitlene har du lært om grunnleggende elektrisitet, Ohms lov, koblinger, komponenter, mikrokontrollere, sensorer og aktuatorer. Nå er det tid for å sette alt sammen i et prosjekt.

Prosjektarbeid er en sentral del av teknologi og forskningslære. Det handler ikke bare om å bygge noe som fungerer – det handler like mye om å planlegge systematisk, dokumentere prosessen og reflektere over resultatet. I dette kapittelet lærer du en strukturert tilnærming til elektronikkprosjekter, fra idé til ferdig produkt.

Prosjektfasene

Et elektronikkprosjekt følger typisk fem faser:

1. Idé og kravspesifikasjon
- Hva skal prosjektet gjøre?
- Hvilke sensorer og aktuatorer trengs?
- Hvilke begrensninger finnes (budsjett, tid, tilgjengelig utstyr)?

2. Design og planlegging
- Lag et blokkdiagram som viser systemets hoveddeler
- Tegn et koblingsskjema med alle komponenter
- Skriv pseudokode for programmet (logikken i klartekst)

3. Prototyping og bygging
- Bygg kretsen på breadboard (loddefri montering)
- Skriv og test programkoden trinnvis (én funksjon om gangen)
- Test og feilsøk underveis

4. Testing og forbedring
- Test at alle funksjoner fungerer som planlagt
- Mål ytelse og presisjon
- Gjør forbedringer basert på testresultatene

5. Dokumentasjon og presentasjon
- Skriv en prosjektrapport
- Dokumenter koblingsskjema, kode og resultater
- Reflekter over hva som fungerte og hva du ville gjort annerledes

Blokkdiagram – den store oversikten

Et blokkdiagram er en forenklet tegning som viser hoveddelene i prosjektet og hvordan de henger sammen. Det gir deg oversikt før du går inn i detaljene.

Eksempel – automatisk plantevanner:

[Jordfuktighets-  ] ──→ [Arduino Uno] ──→ [Vannpumpe   ]
[   sensor (A0)   ]     [            ]     [(via relé)  ]
                         [            ]
[LCD-display      ] ←── [            ] ──→ [LED (status)]
[(I2C: SDA, SCL)  ]     [            ]     [(pinne 13)  ]

Blokkdiagrammet viser at:
- Inngang: Jordfuktighetssensor sender data til Arduino
- Prosessering: Arduino leser sensoren og tar beslutninger
- Utgang: Vannpumpe (via relé), LED og LCD-display

Start alltid med blokkdiagrammet – det hjelper deg å forstå helheten og identifisere hvilke komponenter du trenger.

✏️Eksempel: Planlegge et «smart romovervåker»-prosjekt

Du vil lage et system som måler temperatur og lysnivå i et rom, viser verdiene på Serial Monitor, og aktiverer en alarm (buzzer) hvis temperaturen overstiger 30 °C. Lag en kravspesifikasjon og et blokkdiagram.

Kravspesifikasjon:

KravBeskrivelse
K1Måle temperatur med TMP36-sensor
K2Måle lysnivå med LDR
K3Vise temperatur og lysverdi på Serial Monitor hvert 2. sekund
K4Aktivere buzzer når temperatur > 30 °C
K5LED-indikator: grønn = OK, rød = alarm

Komponentliste:
- Arduino Uno
- TMP36 temperatursensor
- LDR + 10 kΩ motstand
- Piezo-buzzer
- Grønn LED + 220 Ω motstand

- Rød LED + 220 Ω motstand
- Breadboard og ledninger
Blokkdiagram:

[TMP36 (A0)]  ──→  [Arduino Uno]  ──→  [Buzzer (pinne 8)    ]
[LDR   (A1)]  ──→  [            ]  ──→  [Grønn LED (pinne 10)]
                    [            ]  ──→  [Rød LED (pinne 11)  ]
                    [            ]  ──→  [Serial Monitor (USB) ]
Pseudokode:
1. Les temperatur fra TMP36
2. Les lysverdi fra LDR
3. Skriv verdiene til Serial Monitor

4. Hvis temperatur > 30: slå på buzzer og rød LED, slukk grønn LED

5. Ellers: slukk buzzer og rød LED, tenn grønn LED

6. Vent 2 sekunder
7. Gjenta fra steg 1

📝Oppgave 1

Hvilken rekkefølge bør fasene i et elektronikkprosjekt følge?

Systematisk feilsøking
Feilsøking (debugging) er en av de viktigste ferdighetene i elektronikkprosjekter. Når noe ikke fungerer, bør du jobbe systematisk:

Trinn 1: Isoler problemet
- Er det et maskinvareproblem (kobling) eller et programvareproblem (kode)?
- Test med et kjent, enkelt program (f.eks. Blink) for å sjekke at Arduino fungerer

Trinn 2: Del og hersk
- Test hver komponent for seg, ikke alt på en gang
- Bruk Serial.println() for å skrive ut verdier og se hva programmet gjør

Trinn 3: Sjekk de vanligste feilene
- Løse ledninger på breadboard
- Feil pinne i koden vs. koblingen
- Manglende GND-forbindelse (alle komponenter må dele felles jord)
- Manglende forresistans for LED-er
- Feil retning på dioder, LED-er, transistorer
- Syntaksfeil i koden (manglende semikolon, feil parenteser)

Trinn 4: Dokumenter og lær
- Skriv ned hva feilen var og hvordan du løste den
- Neste gang sparer du tid ved å kjenne igjen feilen

Serial.println() – ditt viktigste feilsøkingsverktøy

Det kraftigste verktøyet for feilsøking av Arduino-programmer er Serial.println(). Ved å skrive ut verdier, tilstander og meldinger til Serial Monitor kan du «se» hva programmet gjør innvendig.

Gode feilsøkingspraksiser:

void loop() {
  int sensorVerdi = analogRead(A0);
  Serial.print("Sensor A0 = ");
  Serial.println(sensorVerdi);  // Se om sensoren leses riktig

  float temperatur = (sensorVerdi * 5.0 / 1024.0 - 0.5) * 100.0;
  Serial.print("Beregnet temp = ");
  Serial.println(temperatur);   // Se om konverteringen er riktig

  if (temperatur > 25.0) {
    Serial.println("→ OVER grense, motor PÅ");
    digitalWrite(9, HIGH);
  } else {
    Serial.println("→ Under grense, motor AV");
    digitalWrite(9, LOW);
  }

  delay(1000);
}

Med slike utskrifter kan du raskt se om sensoren gir fornuftige verdier, om beregningen er riktig, og om programflyten følger logikken du forventet.

✏️Eksempel: Komplett prosjekt – smart romovervåker

Skriv den komplette Arduino-koden for «smart romovervåker»-prosjektet: TMP36 (A0), LDR (A1), buzzer (pinne 8), grønn LED (pinne 10), rød LED (pinne 11). Alarm ved temperatur over 30 °C.

// Smart romovervåker
// TMP36 på A0, LDR på A1
// Buzzer på pinne 8, grønn LED pinne 10, rød LED pinne 11

const int TEMP_PIN = A0;
const int LYS_PIN = A1;
const int BUZZER_PIN = 8;
const int GRONN_LED = 10;
const int ROD_LED = 11;
const float ALARM_TEMP = 30.0;

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(GRONN_LED, OUTPUT);
  pinMode(ROD_LED, OUTPUT);
  Serial.begin(9600);
  Serial.println("=== Smart Romovervåker ===");
  Serial.println("Alarm ved temperatur over 30 °C");
  Serial.println("");
}

void loop() {
  // --- Les sensorer ---
  int tempRa = analogRead(TEMP_PIN);
  float spenning = tempRa * (5.0 / 1024.0);
  float temperatur = (spenning - 0.5) * 100.0;

  int lysVerdi = analogRead(LYS_PIN);

  // --- Vis på Serial Monitor ---
  Serial.print("Temp: ");
  Serial.print(temperatur, 1);
  Serial.print(" °C  |  Lys: ");
  Serial.print(lysVerdi);

  // --- Kontroller aktuatorer ---
  if (temperatur > ALARM_TEMP) {
    // ALARM – for varmt!
    digitalWrite(BUZZER_PIN, HIGH);
    digitalWrite(ROD_LED, HIGH);
    digitalWrite(GRONN_LED, LOW);
    Serial.println("  |  ALARM!");
  } else {
    // Alt OK
    digitalWrite(BUZZER_PIN, LOW);
    digitalWrite(ROD_LED, LOW);
    digitalWrite(GRONN_LED, HIGH);
    Serial.println("  |  OK");
  }

  delay(2000);  // Oppdater hvert 2. sekund
}

Koden følger mønsteret: Les sensorer → Behandle data → Styr aktuatorer → Vis status. Dette er et grunnleggende mønster som brukes i de aller fleste styringssystemer, fra enkle hobbyprosjekter til industrielle kontrollsystemer.

📝Oppgave 2

Hvilken av disse er den beste fremgangsmåten for å feilsøke en Arduino-krets som ikke fungerer?

Prosjektdokumentasjon

God dokumentasjon er like viktig som selve prosjektet. En prosjektrapport bør inneholde:

1. Innledning
- Hva er prosjektets mål?
- Hvilken problemstilling løser det?

2. Kravspesifikasjon
- Hva skal prosjektet gjøre? (funksjonskrav)
- Hvilke begrensninger finnes? (tid, budsjett, utstyr)

3. Design
- Blokkdiagram (overordnet systemvisning)
- Koblingsskjema (detaljert kretsskjema)
- Pseudokode eller flytdiagram for programmet

4. Gjennomføring
- Steg-for-steg beskrivelse av byggeprosessen
- Bilder/tegninger av prototypen
- Komplett programkode med kommentarer

5. Testing og resultater
- Hva ble testet? Hvordan?
- Fungerer prosjektet som planlagt?
- Målinger og data (tabeller, grafer)

6. Drøfting og refleksjon
- Hva fungerte bra?
- Hva ville du gjort annerledes?
- Hva lærte du?
- Mulige forbedringer

Tips for god prosjektrapport

Bilder og skjermbilder:
- Ta bilder av prototypen underveis (ikke bare ferdig)
- Inkluder skjermbilder fra Serial Monitor som viser at systemet fungerer
- Fotografer koblingene på breadboardet

Kodekommentarer:
Koden i rapporten skal ha gode kommentarer som forklarer hvorfor, ikke bare hva:

// Dårlig kommentar:
int x = analogRead(A0);  // Les A0

// God kommentar:
int tempRa = analogRead(A0);  // Les TMP36-sensor (gir 10 mV/°C)

Bruk tabeller for testresultater:

TestForventet resultatFaktisk resultatStatus
Temp < 30 °CGrønn LED, ingen lydGrønn LED, ingen lydOK
Temp > 30 °CRød LED, buzzerRød LED, buzzerOK
Sensor frakobletVis feilmeldingViser 0 °CMå forbedres

Ærlighet:
Skriv ærlig om det som ikke fungerte. Det viser at du forstår prosjektet og har lært av prosessen. Ingen forventer et perfekt resultat – det er prosessen og refleksjonen som teller.

Oppsummering – Prosjektarbeid med elektronikk

De fem prosjektfasene:
1. Idé og kravspesifikasjon – definer hva prosjektet skal gjøre
2. Design og planlegging – blokkdiagram, koblingsskjema, pseudokode
3. Prototyping og bygging – breadboard, trinnvis utvikling
4. Testing og forbedring – systematisk testing, iterativ forbedring
5. Dokumentasjon og presentasjon – rapport, refleksjon

Feilsøking:
- Isoler problemet: maskinvare eller programvare?
- Del og hersk: test én komponent om gangen
- Bruk Serial.println() for å «se» hva programmet gjør
- Sjekk vanlige feil: løse ledninger, feil pinne, manglende GND

Dokumentasjon:
- Innledning, kravspek, design, gjennomføring, testing, drøfting
- Bilder, koblingsskjema og kommentert kode
- Ærlig refleksjon over hva som fungerte og hva som kan forbedres

Det viktigste mønsteret i alle styringssystemer:
Les sensorer → Behandle data → Styr aktuatorer → Gjenta

Gratulerer – du har nå det teoretiske grunnlaget for å planlegge, bygge og dokumentere dine egne elektronikkprosjekter med Arduino!

📝Oppgave 3

Velg ett av prosjektene nedenfor og lag en komplett prosjektplan: a) Automatisk nattlys, b) Parkeringsassistent med ultralydsensor, c) Temperaturalarm. Planen skal inneholde: 1) Kravspesifikasjon (minst 4 krav), 2) Komponentliste, 3) Blokkdiagram, 4) Pseudokode for programmet.

📝Oppgave 4

Skriv en komplett prosjektrapport for romovervåker-prosjektet fra eksempelet i dette kapittelet. Inkluder: a) Innledning med prosjektmål, b) Kravspesifikasjon i tabellform, c) Blokkdiagram, d) Koblingsliste (hvilke pinner brukes til hva), e) Den komplette koden med kommentarer, f) En testplan med minst 3 tester og forventede resultater, g) Refleksjon: minst to ting du ville forbedret.

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.