Arduino Multithreading met Protothreading: Een Stapsgewijze Tutorial

Onderdelen en Benodigdheden

Over dit Project

Deze tutorial laat zien hoe je een single-core Arduino kunt laten doen alsof het drie taken tegelijkertijd uitvoert. We gaan:

• De achtergrondverlichting van het LCD laten pulseren met een constante snelheid
• Elke seconde een teller ophogen en op het scherm tonen
• Elke paar seconden verschillende berichten op het scherm laten afwisselen

Wat is Protothreading?

Protothreading is een techniek om multitasking te simuleren op een Arduino. Omdat de Arduino (ATMega328P) een single-core processor is met procedurale code, is echte multithreading onmogelijk. Protothreading lost dit op door taken in tijdsintervallen af te wisselen binnen één hoofdlus.

"Echte" Multithreading vs. Protothreading

Moderne CPU's gebruiken multicore-architectuur en hyperthreading om taken parallel uit te voeren. De Arduino Uno draait op 16 MHz (16 miljoen cycli per seconde), maar heeft slechts één kern. Echte multithreading vereist meerdere kernen; protothreading daarentegen beheert taken sequentieel door te controleren of een taak "rijp" is voor uitvoering.

Hoe Werkt Protothreading?

In plaats van CPU-cycli te delen, verdeelt protothreading werk over lus-iteraties. De meest frequente, niet-blokkerende taak (hier: de pulserende backlight) fungeert als "manager" in de loop(). Tussen de stappen van deze taak door roept de code .check() aan voor de andere taken. Als hun interval verstreken is, voeren ze hun werk uit voordat de hoofdtaak verdergaat.

Belangrijk: Blokkerende operaties (zoals SD-kaart lezen) storen nog steeds de timing van andere protothreads. Voor snelle, niet-blokkerende taken (variabelen updaten, outputs schakelen) werkt het uitstekend.

Aan de Slag

We identificeren drie taken, gerangschikt van minst naar meest blokkerend:

1. Backlight pulseren – snel, periodiek, niet-blokkerend → hoofdthread
2. Teller ophogen – elke 700 ms
3. Tekst rouleren – elke 3000 ms

De TimedAction-bibliotheek beheert de timing. In de loop() staan de for-lussen voor het faden; daarbinnen roepen we numberThread.check() en textThread.check() aan zodat de subtaken niet worden uitgesteld.

Code

De sketch gebruikt de TimedAction.h-bibliotheek (let op: op nieuwere Arduino IDE-versies moet je in TimedAction.h WProgram.h vervangen door Arduino.h).

/* Arduino Protothreading Voorbeeld v1.1 - Drew Alden */
#include <TimedAction.h>
#include <LiquidCrystal.h>

// Pinnen & variabelen
const int backlightPin = 9;
int timerCounter = 0;
int stringNo = 0;
char* stringArray[] = {"Check it out... ", "I have 3 threads", "going at once...", "Cool, huh?! :D "};

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

// Taken
void incrementNumber() {
  lcd.setCursor(0, 1);
  timerCounter++;
  lcd.print(timerCounter);
}

void changeText() {
  lcd.setCursor(0, 0);
  lcd.print(stringArray[stringNo]);
  if (stringNo >= sizeof(stringArray)/sizeof(char*)) {
    stringNo = 0;
    changeText();
  } else {
    stringNo++;
  }
}

// Timers (initialisatie NA functiedefinities!)
TimedAction numberThread = TimedAction(700, incrementNumber);
TimedAction textThread = TimedAction(3000, changeText);

void setup() {
  lcd.begin(16, 2);
  changeText(); // initiële tekst
}

void loop() {
  numberThread.check();
  textThread.check();

  // Backlight fade-in
  digitalWrite(13, HIGH);
  for (int fadeValue = 0; fadeValue <= 255; fadeValue += 10) {
    numberThread.check();
    textThread.check();
    analogWrite(backlightPin, fadeValue);
    delay(20); // kort houden!
  }

  // Backlight fade-out
  digitalWrite(13, LOW);
  for (int fadeValue = 255; fadeValue >= 0; fadeValue -= 10) {
    numberThread.check();
    textThread.check();
    analogWrite(backlightPin, fadeValue);
    delay(20);
  }
}

Let op: TimedAction is verouderd. Voor nieuwe projecten overweeg millis()-gebaseerde scheduling of een RTOS zoals FreeRTOS op ESP32.