Communicatieprotocollen

Embedded projecten gebruiken zelden een microcontroller in zijn eentje: bijna altijd moet die praten met sensoren, displays, andere boards of een PC.
Communicatieprotocollen bepalen hoe bits tussen apparaten bewegen en hoe beide kanten afspraken maken over snelheid, timing en de betekenis van de data.

Op Arduino-achtige boards komen vooral drie protocollen veel voor:

• Serial (UART): point-to-point communicatie met een computer of een andere microcontroller.
• I²C (Two-Wire Interface): een bus voor korte afstanden met één master en (meestal) meerdere slave devices op slechts twee draden.
• SPI (Serial Peripheral Interface): een heel snelle, full-duplex bus voor displays, SD cards en high-speed sensoren.

Op deze pagina geven we kort een introductie van elk protocol en tonen we een minimaal Arduino-voorbeeld.

---

Serial (UART)

Serial (vaak UART genoemd of “Serial over USB”) is het eenvoudigste protocol om mee te beginnen:

• Draden: TX, RX en GND.
• Typisch gebruik: debuggen via de Serial Monitor, simpele commando’s sturen en sensor data loggen.
• Datasnelheid: instellen als een baud rate (bijv. 9600 of 115200).

Bij de meeste Arduino boards is er een Serial-object beschikbaar dat al is aangesloten op de USB-poort.

Voorbeeld: sensor data versturen via Serial

Dit voorbeeld (voor een esp32-s3-devkitc-1-bordje) leest een waarde van GPIO 34 en print die naar de Serial Monitor:

// Simple Serial example for ESP32: read from GPIO34 and print to Serial Monitor

const int SENSOR_PIN = 34;  // ADC pin on many ESP32-S3 DevKit boards

void setup() {
  // Start serial communication at 115200 baud
  Serial.begin(115200);

  Serial.println("Serial ready!");
}

void loop() {
  int sensorValue = analogRead(SENSOR_PIN);

  Serial.print("Sensor value: ");
  Serial.println(sensorValue);

  delay(500);
}

Open de Serial Monitor in de Arduino IDE en controleer dat de baud rate overeenkomt met de waarde in Serial.begin(...).

---

I²C (Two-Wire Interface)

I²C is een busprotocol waarmee één master (jouw Arduino of ESP32) met meerdere slave devices kan praten over dezelfde twee draden:

• Draden: SDA (data), SCL (clock), plus GND en meestal 3.3 V of 5 V voeding.
• Adressering: elk device heeft een 7-bit adres (bijv. 0x27).
• Typisch gebruik: temperatuurs-/druksensoren, real-time clocks, kleine LCD’s en I/O expanders.

Op Arduino gebruik je de Wire library om met I²C te werken.

Voorbeeld: I²C master stuurt een byte

Deze minimale sketch toont een Arduino die als I²C master optreedt en één byte stuurt naar een device op adres 0x27:

#include <Wire.h>

// I2C address of the peripheral device
const uint8_t DEVICE_ADDRESS = 0x27;

void setup() {
  // Initialize I2C as master
  Wire.begin(); // on most Arduino boards: SDA/SCL pins; on ESP32: GPIO 21/22 by default

  // Optional: also initialize Serial for debugging
  Serial.begin(115200);
}

void loop() {
  uint8_t valueToSend = 42;

  Wire.beginTransmission(DEVICE_ADDRESS);
  Wire.write(valueToSend);      // send a single byte
  uint8_t error = Wire.endTransmission(); // actually transmit

  if (error == 0) {
    Serial.println("I2C write OK");
  } else {
    Serial.print("I2C error: ");
    Serial.println(error);
  }

  delay(1000);
}

In een echt project controleer je voor je specifieke device de datasheet om te weten welke bytes/commands je moet sturen en in welke volgorde.

---

SPI (Serial Peripheral Interface)

SPI is een high-speed, full-duplex protocol dat aparte lijnen gebruikt voor data en clock:

• Draden: MOSI, MISO, SCK, per device één chip select (CS), plus GND en voeding.
• Typisch gebruik: kleurendisplays (TFT/OLED), SD cards, high-speed sensoren en externe flash memory.
• Snelheid: veel sneller dan I²C; megabits per seconde komen veel voor.

Op Arduino gebruik je de SPI library.

Voorbeeld: een commando sturen via SPI

Dit voorbeeld laat zien hoe je een single-byte commando naar een SPI device stuurt:

#include <SPI.h>

// Chip Select pin for the SPI device (GPIO 5 is free on many ESP32 DevKit boards)
const int CS_PIN = 5;

void setup() {
  // Configure CS pin
  pinMode(CS_PIN, OUTPUT);
  digitalWrite(CS_PIN, HIGH); // deselect device

  // Initialize SPI for ESP32 VSPI: SCK=18, MISO=19, MOSI=23, CS=CS_PIN
  SPI.begin(18, 19, 23, CS_PIN);

  // Optional: Serial for debug
  Serial.begin(115200);
}

void loop() {
  uint8_t command = 0xA5; // example command byte

  // Select the device by pulling CS low
  digitalWrite(CS_PIN, LOW);

  // Transfer one byte; this both sends and receives a byte
  uint8_t response = SPI.transfer(command);

  // Deselect the device again
  digitalWrite(CS_PIN, HIGH);

  Serial.print("Sent 0x");
  Serial.print(command, HEX);
  Serial.print(", received 0x");
  Serial.println(response, HEX);

  delay(1000);
}

Voor echte peripherals (bijv. displays of SD cards) doe je meestal:

• Configureer SPI mode (0–3), clock speed en bit order om overeen te komen met de datasheet.
• Gebruik een specifieke Arduino library die de low-level SPI commands omzet/afhandelt.

---

Wanneer kies je welk protocol?

• Serial (UART)
  Gebruik voor debuggen, loggen naar een PC, of simpele point-to-point verbindingen tussen twee boards.

• I²C
  Gebruik wanneer je meerdere low-speed peripherals (sensoren, kleine displays) wilt aansluiten met slechts twee draden.

• SPI
  Gebruik voor snelle data-overdracht (displays, SD cards, high-speed sensoren) waarbij je een paar extra draden kunt missen.

De meeste echte projecten combineren deze protocollen: bijvoorbeeld Serial voor debuggen, I²C voor sensoren en SPI voor een display of SD card, allemaal op hetzelfde Arduino-compatibele board.