Relémodul med Arduino: klikk, LED og temperaturstyrt vifte

Et lite klikk, og en LED tennes uten at programmet rører den. Det er hele poenget med en relémodul på Arduino: en svak pinne styrer en bryter som ligger i en annen krets. Her bygger du det i tre trinn på ren 5 V, fra et blinkende testoppsett til en vifte som starter av seg selv når det blir varmt, med temperaturen på LED-matrisen til UNO R4 WiFi.

Nivå

Nybegynner til viderekommen

Tid

Rundt 2 timer for alle tre nivåene

Lodding

Nei

Spenning

Bare 5 V

Du lærer

COM, NO og NC, aktiv LOW, millis() og hysterese

Dette trenger du på bordet

Du trenger ingen loddebolt. Alt kobles med koblingsledninger, og en liten skrutrekker til skruterminalene er det eneste verktøyet.

• 
  Relémodul 1 kanal, MR-008641 stk, selve bryteren i alle tre nivåene
• 
  Arduino UNO R4 WiFi1 stk, styrer reléet og viser status på matrisen
• 
  Koblingsbrett, 830 hull1 stk, fordeler 5 V og jord
• 
  Koblingsledninger, 140 stkHann-hunn til pinnene på modulen, hann-hann ellers
• 
  LED-sett med 1 kΩ-motstander1 LED og 1 motstand, nivå 1 og 2
• Trykknapp 12 x 12 mm1 stk, nivå 2
• 
  DHT22 temperatursensor1 stk, nivå 3
• 
  Vifte 30 mm, 5 V1 stk, 0,85 W, nivå 3

Andre størrelser finner du under koblingsplater og prototyping og koblingsledninger. Et multimeter er ikke påkrevd, men det gir deg et sikkert svar på hvilken terminal som er hva.

Hva skjer inne i reléet når det klikker?

Et relé er en elektromagnet som flytter en bryter. Strøm gjennom spolen trekker til seg et jernanker, ankeret tar med seg en fjærende kontakt, og lyden du hører, er kontakten som slår mot den andre siden. Det finnes ingen elektrisk forbindelse mellom spolen og kontaktene. Bare magnetismen krysser over.

Kjenn igjen relémodulen: pinner, jumper og en merkefelle

Kortet har tre pinner til styring og en skruterminal med tre skruer til lasten. Pinnene er hannpinner, så du trenger hann-hunn-ledninger fra modulen til Arduino eller koblingsbrett.

Produktsiden oppgir aktiv LOW, og all koden i guiden er skrevet ut fra det. Du kan støte på to små avvik: siden nevner reléet JQC-3FF-S-Z og optokobleren EL817, mens bildene viser SRD-05VDC-SL-C og PC817. Styringen er den samme, men les hva som står på ditt eget kort før du slår opp data.

Fra D7 til kontaktene: hva beskytter hva?

En pinne på UNO R4 tåler høyst 8 mA, ifølge databladet fra Arduino. Spolen på SRD-reléet trekker 71,4 mA. Direkte fra pinnen ville det ha vært nesten ni ganger for mye, og det er derfor modulen har en liten rekke komponenter mellom IN1 og spolen.

1. R1 (merket 102, altså 1 kΩ) begrenser strømmen gjennom de to LED-ene, slik at D7 bare må ta imot noen få milliampere når den trekker IN1 lavt.
2. Optokobleren sender signalet som lys over et lite gap. Strøm og støy fra spolesiden kommer ikke tilbake til pinnen samme vei.
3. Transistoren Q1 tar den tunge jobben og leder spolestrømmen til jord, så pinnen slipper.
4. Dioden D2 står over spolen. Når Q1 slår av, prøver spolen å holde strømmen i gang og lager en spenningstopp. D2 gir strømmen en vei å løpe ut på, og det redder Q1.
5. Kontaktene er helt adskilt fra styringen og vet ikke hva som går gjennom dem. Det er også derfor D2 ikke hjelper lasten din: den beskytter bare mot spolen på kortet.

Vil du forstå hvordan Q1 kan styre så mye med så lite, forklarer guiden om transistorer nettopp det.

Nivå 1: reléet klikker og LED-en blinker

LED-en er ikke koblet til noen programmerbar pinne, bare til 5 V via kontaktene. Når den tennes, er det reléet som har gjort det, og du ser med egne øyne at bryteren fungerer. Motstanden på 1 kΩ gir rundt 3 mA, som er nok til tydelig lys fra en vanlig LED.

1. Trekk ut USB-kabelen. Koble alltid om uten strøm.
2. Koble 5V på UNO til plusskinnen og GND på UNO til minusskinnen.
3. Koble VCC på modulen til plusskinnen og GND på modulen til minusskinnen.
4. Koble D7 på UNO til IN1 på modulen.
5. Skru en ledning fra plusskinnen fast i COM. Kontroller med et lett drag at den sitter.
6. Skru en ledning fra NO til kolonne 3 på koblingsbrettet. Sett motstanden fra kolonne 3 til kolonne 8.
7. Sett LED-en med det lange beinet i kolonne 8 og det korte i kolonne 9. Koble kolonne 9 til minusskinnen.
8. La NC stå tom, og la jumperen mellom VCC og JD_VCC sitte.

Installer «Arduino UNO R4 Boards» i Boards Manager, velg «Arduino UNO R4 WiFi» og riktig port, og last opp programmet:

// Nivå 1: reléet slår LED-en av og på hvert andre sekund
const int RELAY_PIN = 7;

// Modulen er aktiv LOW: LOW trekker reléet, HIGH slipper det.
const int RELAY_ON = LOW;
const int RELAY_OFF = HIGH;

void setup() {
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, RELAY_OFF);  // start med reléet sluppet
  Serial.begin(115200);
}

void loop() {
  digitalWrite(RELAY_PIN, RELAY_ON);
  Serial.println("Relé PÅ: klikk, LED-en lyser");
  delay(2000);

  digitalWrite(RELAY_PIN, RELAY_OFF);
  Serial.println("Relé AV: klikk, LED-en slukker");
  delay(2000);
}

Navnene RELAY_ON og RELAY_OFF er den viktigste vanen i hele guiden. De gjør at du aldri trenger å huske at «på» er lavt, og de gjør det enkelt å bytte til en modul som er aktiv HIGH.

Åpne Serial Monitor på 115200 baud. Hver linje skal komme samtidig med et klikk:

Relé PÅ: klikk, LED-en lyser
Relé AV: klikk, LED-en slukker
Relé PÅ: klikk, LED-en lyser
Relé AV: klikk, LED-en slukker

Klikket er testen din

Du har tre tegn å gå etter: klikket, den lille indikator-LED-en D1 på kortet og LED-en på koblingsbrettet. Sammen peker de ut hvor feilen ligger.

Nivå 2: en knapp som starter en tidtaker

Et blinkeprogram med delay() er blindt mens det venter. Her skal knappen virke hele tiden, så vi bytter ut ventingen med millis(), som bare forteller hvor lenge kortet har gått. Programmet ser på klokken, ser på knappen og går rundt igjen, mange tusen ganger i sekundet.

1. Trekk ut USB-kabelen og sett knappen over midtsporet, med beina i kolonne 12 og 14.
2. Koble D4 på UNO til kolonne 12 over sporet.
3. Koble kolonne 14 under sporet til minusskinnen. Da sitter ledningene på to bein på diagonalen, og de er forbundet bare mens du trykker. Bein som står rett overfor hverandre over sporet (for eksempel begge i kolonne 12), er vanligvis forbundet inne i knappen hele tiden, og da leser D4 LOW uten at du trykker. Produktsiden oppgir ikke koblingen inne i knappen, så sjekk gjerne med multimeteret på gjennomgang: det skal bare pipe mens du trykker.

// Nivå 2: knapp starter reléet i 10 sekunder, nytt trykk stopper det
const int RELAY_PIN = 7;
const int BUTTON_PIN = 4;
const int RELAY_ON = LOW;
const int RELAY_OFF = HIGH;

const unsigned long RUN_TIME_MS = 10000;  // hvor lenge lasten står på
const unsigned long DEBOUNCE_MS = 30;     // knappen må være rolig så lenge

bool running = false;
unsigned long startedAt = 0;

int lastReading = HIGH;      // siste råverdi fra knappen
int stableState = HIGH;      // siste verdi som har holdt seg rolig
unsigned long changedAt = 0;  // når råverdien sist endret seg

void setRelay(bool on) {
  running = on;
  digitalWrite(RELAY_PIN, on ? RELAY_ON : RELAY_OFF);
  if (on) {
    startedAt = millis();
  }
}

void setup() {
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, RELAY_OFF);
  pinMode(BUTTON_PIN, INPUT_PULLUP);  // sluppet = HIGH, trykket = LOW
  Serial.begin(115200);
}

void loop() {
  int reading = digitalRead(BUTTON_PIN);

  // Hver gang kontakten spretter, starter ventetiden på nytt.
  if (reading != lastReading) {
    lastReading = reading;
    changedAt = millis();
  }

  // Godta ny verdi først når knappen har vært rolig lenge nok.
  if (millis() - changedAt >= DEBOUNCE_MS && reading != stableState) {
    stableState = reading;
    if (stableState == LOW) {
      setRelay(!running);
      Serial.println(running ? "Start: 10 sekunder" : "Stopp: knappen");
    }
  }

  // Tidtakeren går uten delay(), så knappen virker hele tiden.
  if (running && millis() - startedAt >= RUN_TIME_MS) {
    setRelay(false);
    Serial.println("Stopp: tiden er ute");
  }
}

Tre linjer er verdt å se nærmere på:

• INPUT_PULLUP kobler inn en intern motstand mot 5 V. Pinnen leser HIGH når knappen er sluppet og LOW når du trykker, uten ekstra motstand.
• changedAt = millis() står i blokken som kjører hver gang råverdien endrer seg. Kontaktene i en knapp spretter noen millisekunder når du trykker, og hvert sprett starter ventetiden på nytt. Trykket teller først når alt har vært rolig i 30 ms.
• millis() - startedAt >= RUN_TIME_MS er skrevet som en differanse. Da regner den riktig også når telleren går rundt etter vel 49 døgn.

Start: 10 sekunder
Stopp: tiden er ute
Start: 10 sekunder
Stopp: knappen

Nivå 3: viften som styrer seg selv

Nå får reléet noe å gjøre. DHT22 måler temperaturen, viften starter ved 27 °C og stopper ved 25 °C, og matrisen på kortet viser både tallet og om viften går. Du trenger ikke PC eller skjerm for å se hva som skjer, og det er denne delen du vil vise fram.

1. Trekk ut USB-kabelen og fjern LED-en, motstanden og ledningen fra NO.
2. Koble NO til plussledningen på viften, og koble minusledningen på viften til minusskinnen. Kontakten på viften tar hannpinnene på en hann-hann-ledning. Sjekk polariteten: rød er vanligvis pluss.
3. Koble + på DHT22 til plusskinnen og − på DHT22 til minusskinnen.
4. Koble out på DHT22 til D2 på UNO.
5. D7 til IN1, 5V og GND til skinnene og COM til plusskinnen blir stående som før.

Hvorfor to grenser?

Med bare én grense på 26 °C ville hver lille svingning rundt 26,0 gi et klikk. Grafen under viser det på samme temperaturkurve: to grenser gir to klikk, én grense gir åtte. Dette kalles hysterese, og termostaten på en panelovn gjør noe tilsvarende.

Hele programmet

// Nivå 3: vifte styrt av temperatur, med status på LED-matrisen
#include <Arduino_LED_Matrix.h>
#include <DHT.h>

const int RELAY_PIN = 7;
const int DHT_PIN = 2;
const int RELAY_ON = LOW;
const int RELAY_OFF = HIGH;

const float TEMP_ON = 27.0;   // viften starter ved denne temperaturen
const float TEMP_OFF = 25.0;  // viften stopper ved denne temperaturen

const unsigned long READ_EVERY_MS = 2500;   // DHT22 trenger minst 2 sekunder
const unsigned long DRAW_EVERY_MS = 200;    // propellen på matrisen
const unsigned long MIN_SWITCH_MS = 15000;  // minste tid mellom to reléskift
const int MAX_FAILED_READS = 3;             // så mange feil før viften stopper

// Sifre og bokstaver på 3 x 5 lysdioder. Hver rad er tre biter.
const uint8_t DIGITS[10][5] = {
  {0b111, 0b101, 0b101, 0b101, 0b111},  // 0
  {0b010, 0b110, 0b010, 0b010, 0b111},  // 1
  {0b111, 0b001, 0b111, 0b100, 0b111},  // 2
  {0b111, 0b001, 0b111, 0b001, 0b111},  // 3
  {0b101, 0b101, 0b111, 0b001, 0b001},  // 4
  {0b111, 0b100, 0b111, 0b001, 0b111},  // 5
  {0b111, 0b100, 0b111, 0b101, 0b111},  // 6
  {0b111, 0b001, 0b010, 0b010, 0b010},  // 7
  {0b111, 0b101, 0b111, 0b101, 0b111},  // 8
  {0b111, 0b101, 0b111, 0b001, 0b111},  // 9
};
const uint8_t LETTER_E[5] = {0b111, 0b100, 0b110, 0b100, 0b111};
const uint8_t LETTER_R[5] = {0b000, 0b110, 0b100, 0b100, 0b100};
const uint8_t DASH[5] = {0b000, 0b000, 0b111, 0b000, 0b000};

DHT dht(DHT_PIN, DHT22);
ArduinoLEDMatrix matrix;
uint8_t frame[8][12];

float temperature = 0;
bool haveReading = false;
int failedReads = 0;
bool fanOn = false;
bool propellerTurned = false;
unsigned long lastRead = 0;
unsigned long lastDraw = 0;
unsigned long lastSwitch = 0;

bool sensorFailed() {
  return failedReads >= MAX_FAILED_READS;
}

void setFan(bool on) {
  if (on == fanOn) {
    return;
  }
  fanOn = on;
  lastSwitch = millis();
  digitalWrite(RELAY_PIN, on ? RELAY_ON : RELAY_OFF);
  Serial.println(on ? "Klikk: viften starter" : "Klikk: viften stopper");
}

void readSensor() {
  float value = dht.readTemperature();
  if (isnan(value)) {
    failedReads++;
    Serial.println("Feil: ingen gyldig måling fra DHT22");
    return;
  }
  failedReads = 0;
  temperature = value;
  haveReading = true;
  Serial.print("Temperatur: ");
  Serial.print(temperature, 1);
  Serial.println(fanOn ? " C, vifte PÅ" : " C, vifte AV");
}

void updateFan() {
  // Sensorfeil går foran alt annet: uten måling står viften stille.
  if (sensorFailed()) {
    setFan(false);
    return;
  }
  if (!haveReading || millis() - lastSwitch < MIN_SWITCH_MS) {
    return;
  }
  // Hysterese: to grenser, så reléet ikke klikker rundt én enkelt verdi.
  if (!fanOn && temperature >= TEMP_ON) {
    setFan(true);
  } else if (fanOn && temperature <= TEMP_OFF) {
    setFan(false);
  }
}

void drawGlyph(const uint8_t glyph[5], int col) {
  for (int row = 0; row < 5; row++) {
    for (int bit = 0; bit < 3; bit++) {
      frame[row + 1][col + bit] = (glyph[row] >> (2 - bit)) & 1;
    }
  }
}

void drawPropeller() {
  frame[3][10] = 1;  // navet lyser alltid
  if (!fanOn) {
    return;
  }
  propellerTurned = !propellerTurned;
  if (propellerTurned) {
    frame[2][10] = frame[4][10] = frame[3][9] = frame[3][11] = 1;
  } else {
    frame[2][9] = frame[2][11] = frame[4][9] = frame[4][11] = 1;
  }
}

void draw() {
  memset(frame, 0, sizeof(frame));
  if (sensorFailed()) {
    drawGlyph(LETTER_E, 0);
    drawGlyph(LETTER_R, 4);
    drawGlyph(LETTER_R, 8);
  } else if (!haveReading) {
    drawGlyph(DASH, 0);
    drawGlyph(DASH, 4);
    drawPropeller();
  } else {
    int shown = constrain((int)lround(temperature), 0, 99);
    drawGlyph(DIGITS[shown / 10], 0);
    drawGlyph(DIGITS[shown % 10], 4);
    drawPropeller();
  }
  matrix.renderBitmap(frame, 8, 12);
}

void setup() {
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, RELAY_OFF);
  Serial.begin(115200);
  dht.begin();
  matrix.begin();
}

void loop() {
  unsigned long now = millis();
  if (now - lastRead >= READ_EVERY_MS) {
    lastRead = now;
    readSensor();
    updateFan();
  }
  if (now - lastDraw >= DRAW_EVERY_MS) {
    lastDraw = now;
    draw();
  }
}

Dette gjør de viktigste delene:

• updateFan() sjekker sensorfeil først. Tre mislykkede målinger på rad stopper viften med en gang, selv om MIN_SWITCH_MS ikke er gått ut. Hva som er trygt ved feil, avhenger av lasten: for en vifte i en øvelse er det riktig å slå den av, men for andre laster må du tenke selv.
• lastSwitch starter på null, så viften kan ikke starte de første 15 sekundene etter oppstart. Det hindrer at en omstart i en løkke gir rask klikking.
• READ_EVERY_MS er 2500 fordi DHT22 trenger minst 2 sekunder mellom målingene.
• renderBitmap(frame, 8, 12) sender hele tabellen på 8 rader og 12 kolonner til matrisen. Vi tegner sifrene selv, med tre biter per rad.

Slik skal matrisen se ut

I Serial Monitor ser det slik ut når du varmer opp sensoren. Verdiene er eksempler, og Arduino skriver desimalpunktum:

Temperatur: 24.6 C, vifte AV
Temperatur: 26.2 C, vifte AV
Temperatur: 27.1 C, vifte AV
Klikk: viften starter
Temperatur: 27.4 C, vifte PÅ
Temperatur: 25.6 C, vifte PÅ
Temperatur: 25.0 C, vifte PÅ
Klikk: viften stopper

Tre typiske feil, og hva som er riktig

Hvorfor reléet aldri skal ha 230 V på koblingsbrettet

Teksten «10A 250VAC» på reléet er tall for selve komponenten. Den sier ingenting om resten av byggingen:

• Kortet er åpent. Loddepunktene på undersiden og skruene på oversiden er uisolerte, og noen millimeter unna ligger ledningene til Arduinoen din.
• Ledningene er ikke laget for det. Koblingsledninger og koblingsbrett er laget for lave spenninger og små strømmer, og en ledning kan falle ut mens alt står på.
• Feil er usynlige. Det holder at en løs ledning berører noe den ikke skal. Støt og brann gir ingen forvarsel.
• Isolasjonen er ikke godkjent. Modulen har ingen kapsling, sikring eller jording, og den er ikke et produkt du kan montere i en installasjon.

Vil du faktisk styre lys, ovner eller stikkontakter?

Og ESP32? Dette må du sjekke ved 3,3 V

Mange vil bruke et ESP32-kort i stedet for UNO, men koblingen kan ikke kopieres rett over. Vi har heller ikke testet kombinasjonen på benken, så her er det du selv må kontrollere. Grunnen er enkel: UNO R4 har 5 V på pinnene, mens ESP32 har 3,3 V, og den har en absolutt øvre grense på 3,6 V ifølge databladet fra Espressif.

Den enkleste veien utenom alle tre spenningsspørsmålene er en liten NPN-transistor mellom ESP32 og IN1. Pinnen ser da bare transistorens base, og IN1 ser ingen 3,3 V-utgang. Logikken snur samtidig: HIGH på GPIO26 slår reléet på, og motstanden på 10 kΩ holder transistoren av mens ESP32 starter.

// ESP32 via NPN-transistor: HIGH på GPIO26 trekker IN lavt og slår reléet på
const int RELAY_PIN = 26;

void setup() {
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, LOW);  // transistoren er av ved oppstart
  Serial.begin(115200);
}

void loop() {
  digitalWrite(RELAY_PIN, HIGH);
  Serial.println("Relé PÅ");
  delay(2000);

  digitalWrite(RELAY_PIN, LOW);
  Serial.println("Relé AV");
  delay(2000);
}

Programmet passer for et vanlig ESP32-utviklingskort. Biblioteket til matrisen finnes bare for UNO R4 WiFi, så nivå 3 må skrives om med for eksempel Serial Monitor eller en egen skjerm for å kjøre på ESP32.

Relé til Arduino: 5 V, 12 V, 24 V eller 230 V?

Velg relémodul etter spenningen du har til spolen, ikke etter lasten. Lasten har sin egen krets, og den må holde seg innenfor kontaktenes merking og denne guidens lavspenningsgrense.

Relémodul med Arduino: hvordan kobler du den?

Tre ledninger går til Arduino: VCC til 5V, GND til GND og IN1 til en digital pinne, her D7. Lasten går på COM og NO (COM1 og NO1 for kanal 1 og COM2 og NO2 for kanal 2 på en modul med to kanaler), som er helt adskilt fra styringen.

Flere finner du under releer. Et 24 V-relé kan ikke styres rett fra en pinne, og transistorguiden viser hvordan en liten strøm styrer en større. Kortene finner du under Arduino og ESP32.

Kan Arduino styre 230 V med et relé?

Ikke i et prosjekt på benken. Selv om reléet er merket 250 VAC, er modulen åpen og koblingsbrettet laget for lav spenning, og fast installasjon skal utføres av en registrert elvirksomhet. Noen kaller dette 220 V, men det er det samme nettet.

Skal du styre noe på 230 V, er et ferdig WiFi-relé for 230 V montert av elektriker, den riktige veien, og guiden om smarte reléer hjelper deg med å velge.

Vanlige spørsmål

Kan jeg bruke en relémodul med Arduino uten transistor?

Ja, fordi transistoren allerede sitter på modulen. En løs reléspole kan derimot aldri kobles direkte til en pinne: spolen trekker rundt 71 mA, og pinnen på UNO R4 tåler 8 mA.

Hvorfor er modulen aktiv LOW?

Fordi LED-en i optokobleren henger mellom 5 V og IN1. Det går bare strøm når pinnen trekker IN1 ned til 0 V. En bonus er at reléet normalt holder seg av mens UNO starter, fordi en pinne som ennå ikke er utgang, ikke trekker IN1 lavt.

Kan jeg styre 12 V med denne modulen?

Ja, lasten kan ha sin egen spenning, fordi kontaktene er adskilt fra styringen. Kontaktene er merket 10 A ved 30 VDC. Sett egen sikring og en diode over induktive laster, og koble 12 V-kretsen til COM og NO, aldri til koblingsbrettets skinner.

Kan jeg bruke PWM på reléet?

Nei. Reléet trenger opptil 10 ms på å trekke, og hvert klikk sliter på kontaktene. Til fartsregulering brukes en MOSFET.

Hvorfor velger du D7 og ikke en annen pinne?

D7 er ikke opptatt av noe annet i prosjektet og er en vanlig digital pinne. Du kan bruke en annen, så lenge du endrer RELAY_PIN. Unngå D0 og D1 hvis du senere vil bruke maskinvarens serieport.

Hvor går du videre?

Nå kan du la en sensor bestemme over en bryter. Neste naturlige steg er å forstå hvorfor koden din ser ut som den gjør i Arduino-guiden for nybegynnere, å lese temperaturen på en skjerm i LCD- og DHT22-prosjektet eller å bytte relé mot MOSFET og få full fartsregulering med guiden om PWM og motorer.

Fakta her er hentet fra databladet til UNO R4 WiFi (8 mA per pinne, USB-forsyning), Arduinos veiledning for LED-matrisen, databladet til SRD-reléet og databladet til ESP32. Koden er kompilert for UNO R4 WiFi, men vi har ikke kjørt den på fysisk maskinvare, så test den selv etter stegene over.