Basis · 12 min leestijd

Wat is SPI? MOSI-, MISO-, SCK- en CS-pinnen uitgelegd voor Arduino

Wat is SPI en hoe werkt het? MOSI-, MISO-, SCK- en CS-pinnen, SPI-modi en snelheid, meerdere apparaten, pinnen van Uno, Mega, ESP32 en Pico, en het conflict tussen SD-kaart en RFID.

SPI (Serial Peripheral Interface) is een communicatiemethode waarmee een microcontroller via vier draden heel snel data uitwisselt met apparaten zoals SD-kaarten, RFID-lezers, kleuren-tft-displays of draadloze modules. Er is een kloklijn (SCK), twee aparte datalijnen voor elke richting (MOSI en MISO) en een CS-lijn die kiest met welk apparaat wordt gepraat. Doordat SPI tientallen keren sneller kan zijn dan I2C, is het de eerste keuze voor modules die veel data verplaatsen.

In dit artikel leer je hoe SPI werkt, wat de pinnamen en de nieuwere benaming zijn, de vier SPI-modi, de snelheidslimieten, de pinnen van de Arduino Uno, Mega, ESP32 (VSPI en HSPI) en Raspberry Pi Pico, hoe je meerdere apparaten op dezelfde bus aansluit en waarom een SD-kaart en een RC522 RFID-lezer samen problemen geven. In het laatste deel vergelijken we SPI met I2C en UART.

Wat is SPI en hoe werkt het?

SPI heeft altijd één controller (vroeger master genoemd) en een of meer randapparaten (vroeger slaves genoemd). Alleen de controller genereert de klok; de Arduino start het gesprek dus, bepaalt de snelheid en beëindigt het. Bij elke klokpuls stuurt de controller één bit over MOSI, terwijl het randapparaat tegelijk één bit terugstuurt over MISO. De schuifregisters aan beide kanten vormen een soort ring: na 8 klokpulsen is de byte van de controller naar het randapparaat verschoven en de byte van het randapparaat naar de controller. Daarom is SPI full duplex: lezen en schrijven gebeuren tegelijk.

LijnOude naamNieuwe naamRichtingRol
SCK / SCLKSerial ClockSCKController → randapparaatKloksignaal; bij elke puls verschuift één bit
MOSIMaster Out Slave InCOPI / SDOController → randapparaatData van de Arduino naar de module
MISOMaster In Slave OutCIPO / SDIRandapparaat → controllerData van de module terug naar de Arduino
CS / SSSlave SelectCS (Chip Select)Controller → randapparaatDie module luistert zolang de lijn LOW is; elk apparaat krijgt een eigen CS

De labels op modules zijn niet altijd hetzelfde, en dat is de grootste bron van verwarring. Op de RC522 RFID-module heet de CS-lijn SDA (dit heeft niets met de SDA van I2C te maken), op de nRF24L01 heet hij CSN, op de MCP3008 CS/SHDN, en op sommige displays zie je namen als DIN (MOSI), CLK (SCK) en DOUT (MISO). De regel is simpel: de datainput (DIN, SDI, MOSI) gaat naar de MOSI van de Arduino en de dataoutput (DOUT, SDO, MISO) gaat naar de MISO van de Arduino.

  1. De controller trekt de CS-lijn van het apparaat waarmee hij wil praten LOW. Alle andere apparaten houden hun CS HIGH en laten de MISO-lijn los.
  2. De controller begint klokpulsen te genereren op SCK.
  3. Bij elke puls gaat er één bit uit over MOSI en komt er één bit binnen over MISO. De bitvolgorde is meestal most significant bit first (MSB first).
  4. Zodra het vereiste aantal bytes (commando, adres, data) is overgedragen, zet de controller CS weer HIGH en voert het apparaat de bewerking uit.

SPI-modi: CPOL en CPHA

SPI kent geen enkele vaste standaard; apparaten verschillen in het niveau waarop de klok in rust staat (CPOL, klokpolariteit) en de klokflank waarop data wordt gelezen (CPHA, klokfase). De vier combinaties van deze twee instellingen vormen de vier SPI-modi. Als de controller en het apparaat niet in dezelfde modus staan, schuift de data één bit op en lees je betekenisloze waarden. Gelukkig gebruikt de overgrote meerderheid van de modules modus 0.

ModusCPOLCPHAKlok in rustFlank waarop data wordt gelezenVoorbeeldapparaten
SPI_MODE000LOWStijgendSD-kaart, RC522, nRF24L01, MAX7219, MCP3008, 74HC595
SPI_MODE101LOWDalendSommige adc- en driverchips
SPI_MODE210HIGHDalendZelden gebruikt
SPI_MODE311HIGHStijgendADXL345-versnellingsmeter, sommige ST7789-displays zonder CS-pin
Als je van een module steeds 0xFF, 0x00 of wisselende onzinwaarden blijft lezen, controleer dan eerst de SPI-modus en de maximale klokfrequentie in de datasheet. Als je de snelheid verlaagt naar 1 MHz en het opnieuw probeert, zie je snel of het probleem in de bedrading of in de instellingen zit.

SPI-snelheid en kabellengte

Bij SPI bepaalt de controller de snelheid en meestal is het apparaat zelf de beperking. De Arduino Uno haalt maximaal 8 MHz, de helft van zijn klok van 16 MHz; de standaardwaarde van de SPI-bibliotheek is 4 MHz. De ESP32 kan op zijn eigen SPI-pinnen (IO_MUX) tot 80 MHz genereren, en de limiet daalt wanneer het signaal via de GPIO-matrix naar andere pinnen wordt geleid. De Raspberry Pi Pico haalt ongeveer 62,5 MHz met een systeemklok van 125 MHz. Snelle SPI-signalen vragen om korte draden: met een breadboard en jumperdraden van 10–20 cm zijn een paar MHz geen probleem; houd de draden bij 20–30 MHz en hoger kort en gebruik zo mogelijk gesoldeerde verbindingen. Lengtes van meerdere meters zijn niet geschikt voor SPI.

ApparaatRolMaximale SPI-klok (datasheet)SPI-modus
MicroSD-kaartDatalogging400 kHz bij het opstarten, daarna tot 25 MHzModus 0
RC522 (MFRC522)RFID-lezer10 MHzModus 0
nRF24L012,4 GHz draadloos10 MHzModus 0
MAX7219Ledmatrix / 7-segment10 MHzModus 0
MCP30088-kanaals 10-bits adc3,6 MHz bij 5 V, 1,35 MHz bij 2,7 VModus 0 of 3
ILI9341Kleuren-tft van 2,4–3,2 inch10 MHz bij schrijven (in de praktijk veel sneller aangestuurd)Modus 0

SPI-pinnen: Arduino Uno, Mega, ESP32 en Raspberry Pi Pico

LijnArduino Uno / NanoArduino MegaESP32 VSPI (standaard)ESP32 HSPIRaspberry Pi Pico SPI0
SCKD13D52GPIO 18GPIO 14GP18
MOSID11D51GPIO 23GPIO 13GP19 (TX)
MISOD12D50GPIO 19GPIO 12GP16 (RX)
CS (standaard)D10D53GPIO 5GPIO 15GP17
Logisch niveau5 V5 V3,3 V3,3 V3,3 V

Op de Uno zitten dezelfde SPI-lijnen ook op de 6-pins ICSP-header aan de rand van het board; op boards zoals de Leonardo en Micro is SPI alleen beschikbaar via ICSP. D10 is niet verplicht voor CS; je kunt elke digitale pin gebruiken. Laat D10 op de Uno echter niet als input staan: als de SPI-hardware LOW leest op D10 terwijl die een input is, valt hij uit de controllermodus. SPI.begin() maakt van deze pin automatisch een output, en je moet hem niet voor een andere taak als input instellen. Op de ESP32 gebruikt het Arduino-object SPI standaard VSPI; dankzij de GPIO-matrix kun je SPI ook naar bijna alle pinnen verplaatsen die je wilt. Op de Pico kunnen SPI0 en SPI1 aan meerdere pingroepen worden toegewezen (bijvoorbeeld GP10, GP11, GP12 voor SPI1); zie de tool Pinout voor details.

De RC522, de nRF24L01 en SD-kaarten zelf zijn apparaten van 3,3 V. Als je ze rechtstreeks aansluit op de 5V-signalen van de Uno, kunnen ze na verloop van tijd beschadigen. De meeste kant-en-klare SD-kaartmodules hebben een niveauconverter; voed de RC522 en nRF24L01 vanaf de 3V3-pin en overweeg een logische niveauconverter op de signaallijnen. De ESP32 en Pico werken al op 3,3 V, dus die zijn direct compatibel met deze apparaten.

De Arduino SPI-bibliotheek: basisfuncties

FunctieWat doet het?
SPI.begin()Start de SPI-hardware; maakt van de pinnen SCK, MOSI en SS outputs.
SPISettings(speed, MSBFIRST, SPI_MODE0)Bundelt de snelheid, bitvolgorde en modus van een apparaat in één object.
SPI.beginTransaction(settings)Past de instellingen toe en reserveert de bus voor dit apparaat; maakt het wisselen tussen apparaten met verschillende instellingen veilig.
SPI.transfer(byte)Verstuurt één byte en geeft de tegelijk ontvangen byte terug.
SPI.transfer16(value)Verstuurt en ontvangt een 16-bitswaarde in één keer.
SPI.transfer(buffer, length)Verstuurt een array; de ontvangen bytes overschrijven dezelfde array.
SPI.endTransaction()Geeft de bus vrij; wordt aangeroepen nadat je CS HIGH hebt gezet.

Eerste voorbeeld: data via SPI naar een 74HC595 sturen

De makkelijkste manier om SPI te begrijpen is met een 74HC595-schuifregister, want de 595 is eigenlijk het simpelste SPI-randapparaat, eentje zonder MISO. De MOSI-pin van de Arduino gaat naar de DS-ingang van de 595, SCK naar SH_CP en D10 naar ST_CP, die als latch dient. In tegenstelling tot de functie shiftOut() verstuurt hardware-SPI de byte in enkele microseconden:

C++ (Arduino IDE)
1// Donanım SPI ile 74HC595: 8 LED'i iki kabloyla sürmek / 74HC595 over hardware SPI: 8 LEDs from two data wires
2// D11 (MOSI) -> DS (14), D13 (SCK) -> SH_CP (11), D10 -> ST_CP / latch (12)
3#include <SPI.h>
4
5const int LATCH_PIN = 10;     // 595'te CS gibi davranır / acts like CS on the 595
6
7void write595(byte value) {
8  SPI.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0));  // 4 MHz, mod 0 / 4 MHz, mode 0
9  digitalWrite(LATCH_PIN, LOW);
10  SPI.transfer(value);                 // 8 biti gönder / shift out 8 bits
11  digitalWrite(LATCH_PIN, HIGH);       // yükselen kenarda çıkışlara aktar / latch on the rising edge
12  SPI.endTransaction();
13}
14
15void setup() {
16  pinMode(LATCH_PIN, OUTPUT);
17  digitalWrite(LATCH_PIN, HIGH);
18  SPI.begin();
19}
20
21void loop() {
22  for (int i = 0; i < 8; i++) {        // yürüyen ışık / running light
23    write595(1 << i);
24    delay(100);
25  }
26}

Data lezen via SPI: de MCP3008-adc

Om full-duplexcommunicatie te zien, gebruiken we de MCP3008. Deze chip voegt 8 extra analoge 10-bitsingangen toe aan de Arduino; het is een goed alternatief voor de niet-lineaire adc van de ESP32 of de slechts 3 analoge ingangen van de Pico. De basis van analoog lezen hebben we behandeld in het artikel Wat is een adc?. Bedrading: CLK → D13, DOUT → D12, DIN → D11, CS → D10, VDD en VREF → 5V, AGND en DGND → GND.

C++ (Arduino IDE)
1// MCP3008 (8 kanal, 10 bit ADC) okuma / Reading an MCP3008 (8-channel 10-bit ADC)
2// D13 -> CLK, D12 <- DOUT, D11 -> DIN, D10 -> CS/SHDN
3#include <SPI.h>
4
5const int CS_PIN = 10;
6SPISettings mcpSettings(1000000, MSBFIRST, SPI_MODE0);   // 1 MHz, mod 0 / 1 MHz, mode 0
7
8int readMCP3008(byte channel) {
9  SPI.beginTransaction(mcpSettings);
10  digitalWrite(CS_PIN, LOW);                   // cihazı seç / select the chip
11  SPI.transfer(0x01);                          // başlangıç biti / start bit
12  byte high = SPI.transfer(0x80 | (channel << 4));   // tek uçlu + kanal / single-ended + channel
13  byte low = SPI.transfer(0x00);               // kalan 8 bit / remaining 8 bits
14  digitalWrite(CS_PIN, HIGH);                  // seçimi bırak / release the chip
15  SPI.endTransaction();
16  return ((high & 0x03) << 8) | low;           // 10 bitlik sonuç / 10-bit result
17}
18
19void setup() {
20  Serial.begin(9600);
21  pinMode(CS_PIN, OUTPUT);
22  digitalWrite(CS_PIN, HIGH);                  // başta seçili değil / not selected at start
23  SPI.begin();
24}
25
26void loop() {
27  int raw = readMCP3008(0);
28  float volts = raw * 5.0 / 1023.0;
29  Serial.print("CH0: ");
30  Serial.print(raw);
31  Serial.print("  ");
32  Serial.print(volts, 2);
33  Serial.println(" V");
34  delay(500);
35}

Hier sturen we drie bytes en ontvangen we tegelijk drie bytes. De eerste byte (0x01) is alleen het startbit; de tweede byte bevat de single-ended modus en het kanaalnummer, terwijl de MCP3008 de bovenste 2 bits van het resultaat terugstuurt. De derde byte is 0x00; de inhoud maakt niet uit, hij wordt alleen verstuurd om klokpulsen te genereren en de overige 8 bits van het resultaat te ontvangen. Bij SPI betekent "lezen" altijd dat je iets verstuurt. Het resultaat ligt tussen 0 en 1023 en wordt omgerekend naar volt ten opzichte van VREF (hier 5 V).

Meerdere SPI-apparaten: aparte CS-lijnen

Het grootste verschil tussen SPI en I2C is dat SPI geen adressen gebruikt. Apparaten delen de lijnen SCK, MOSI en MISO, en elk krijgt van de Arduino zijn eigen CS-draad. Alleen het apparaat waarvan CS LOW is luistert, en alleen dat apparaat zet data op MISO. Drie apparaten hebben 3 + 3 = 6 draden nodig, vijf apparaten 3 + 5 = 8 draden; het aantal pinnen groeit met het aantal apparaten. Sommige chips zoals de 74HC595 en MAX7219 kun je in plaats daarvan in een daisy chain koppelen: de uitgang van de ene gaat naar de ingang van de volgende en ze worden allemaal met één CS aangestuurd.

  • Er mag maar één CS tegelijk LOW zijn. Als twee apparaten tegelijk worden geselecteerd, botsen ze op de MISO-lijn en lees je van beide beschadigde data.
  • Maak in setup() eerst van elke CS-pin een output en trek hem HIGH, en start daarna de bibliotheken. Een zwevende CS-pin kan willekeurig LOW lijken en de bus overnemen.
  • Gebruik beginTransaction voor elk apparaat. Een SD-kaart wil misschien 25 MHz en een MCP3008 1 MHz; transacties passen bij elke wissel automatisch de juiste snelheid en modus toe.
  • Als je SPI binnen interrupts gebruikt, meld dat dan aan de bibliotheek met SPI.usingInterrupt(), of doe geen SPI-werk binnen de interrupt.
  • Een pull-upweerstand van 10 kΩ op de CS-lijn van elk apparaat voorkomt dat apparaten zichzelf selecteren terwijl de Arduino opstart of reset.

SD-kaart en RFID op dezelfde bus: waarom werkt het niet?

Een klassieke vraag op Arduino-fora: de RC522 RFID werkt op zichzelf, de SD-kaartmodule werkt op zichzelf, maar als beide op dezelfde SPI-bus zitten, valt een of vallen beide stil. Zelfs als de CS-pinnen in de software kloppen, ligt het probleem meestal in de hardware. Veel goedkope SD-kaartmodules hebben een 74LVC125-bufferchip die 5V-signalen omzet naar 3,3 V, en het kanaal van deze chip dat de MISO-lijn aanstuurt is altijd ingeschakeld. Zelfs als de CS van de SD-kaart HIGH is, laat de module MISO dus niet los; als de RC522 probeert te antwoorden, wordt de lijn door twee uitgangen tegelijk bevochten.

  • Kies de juiste module: modules die MISO op hoge impedantie zetten wanneer CS HIGH is, delen de bus zonder problemen. Of een module de lijn loslaat, kun je controleren door MISO bij CS HIGH eerst via 10 kΩ naar GND en daarna naar 5 V te trekken en met een multimeter te meten.
  • Verbind de enable-pin van de buffer met CS: als je goed kunt solderen, verhelpt het het probleem definitief om de OE-pin van het MISO-kanaal van de 74LVC125 van GND los te halen en met de CS-lijn van de module te verbinden.
  • Plaats een serieweerstand op MISO: een serieweerstand van ongeveer 1 kΩ op de MISO-uitgang van de SD-module zorgt dat de RC522 de lijn kan overheersen. Het is een eenvoudige noodoplossing die wel de snelheid beperkt.
  • Gebruik een aparte SPI-bus: als je op de ESP32 de SD-kaart op VSPI en de RC522 op HSPI aansluit, komen de twee apparaten nooit met elkaar in aanraking. De Uno heeft geen tweede hardware-SPI, dus die optie bestaat daar niet.
  • Let op de opstartvolgorde: zet eerst alle CS-pinnen HIGH, roep dan SPI.begin() aan, daarna SD.begin() en PCD_Init(). Het onderstaande voorbeeld volgt deze volgorde.
C++ (Arduino IDE)
1// Aynı SPI hattında SD kart ve RC522 RFID / SD card and RC522 RFID on the same SPI bus
2// Ortak / shared: D11 MOSI, D12 MISO, D13 SCK. CS: SD -> D4, RC522 SDA(SS) -> D10, RC522 RST -> D9
3#include <SPI.h>
4#include <SD.h>
5#include <MFRC522.h>
6
7const int SD_CS = 4;
8const int RFID_CS = 10;
9const int RFID_RST = 9;
10
11MFRC522 rfid(RFID_CS, RFID_RST);
12
13void setup() {
14  Serial.begin(9600);
15  // Önce TÜM CS pinlerini HIGH yap: hiçbir cihaz hattı meşgul etmesin
16  // First drive ALL CS pins HIGH so no device grabs the bus
17  pinMode(SD_CS, OUTPUT);
18  digitalWrite(SD_CS, HIGH);
19  pinMode(RFID_CS, OUTPUT);
20  digitalWrite(RFID_CS, HIGH);
21
22  SPI.begin();
23  if (!SD.begin(SD_CS)) {
24    Serial.println(F("SD bulunamadi / SD not found"));
25  }
26  rfid.PCD_Init();
27  Serial.println(F("Karti okut / Scan a card"));
28}
29
30void loop() {
31  if (!rfid.PICC_IsNewCardPresent() || !rfid.PICC_ReadCardSerial()) return;
32
33  String uid = "";
34  for (byte i = 0; i < rfid.uid.size; i++) {
35    if (rfid.uid.uidByte[i] < 0x10) uid += "0";
36    uid += String(rfid.uid.uidByte[i], HEX);
37  }
38  rfid.PICC_HaltA();
39
40  File f = SD.open("kartlar.txt", FILE_WRITE);   // kütüphane CS'yi kendisi yönetir / the library handles CS itself
41  if (f) {
42    f.print(millis());
43    f.print(";");
44    f.println(uid);
45    f.close();
46    Serial.println("Kaydedildi / Saved: " + uid);
47  } else {
48    Serial.println(F("Dosya acilamadi / File open failed"));
49  }
50}

In deze code sturen de SD-bibliotheek en de MFRC522-bibliotheek hun eigen CS-pinnen LOW en HIGH; jij hoeft alleen beide aan het begin HIGH te laten en ervoor te zorgen dat de hardware MISO goed deelt. De code schrijft de UID van elke gescande kaart, samen met een tijdstempel, naar het bestand kartlar.txt. Op de Uno gebruiken deze twee bibliotheken samen ongeveer de helft van het RAM; de macro F() maakt ruimte vrij door constante strings in flash te bewaren.

VSPI en HSPI op de ESP32: twee aparte SPI-bussen

De ESP32 heeft vier SPI-eenheden; SPI0 en SPI1 zijn gereserveerd voor het interne flashgeheugen, waardoor VSPI (SPI3) en HSPI (SPI2) voor jou overblijven. Beide gebruiken is de schoonste manier om apparaten met sterk verschillende snelheden en modi te scheiden of om de MISO-botsing hierboven te ontlopen. In de Arduino-core maak je een SPIClass-object voor de tweede bus en geef je het zijn pinnen met begin(). De onderstaande code laat de SD-kaart op de standaard VSPI draaien en de MCP3008 op HSPI, en voegt elke seconde een meting toe aan een csv-bestand:

C++ (Arduino IDE)
1// ESP32: iki ayrı SPI hattı / two separate SPI buses
2// VSPI (varsayılan SPI / default SPI): SD kart / SD card -> SCK 18, MISO 19, MOSI 23, CS 5
3// HSPI: MCP3008 -> SCK 14, MISO 12, MOSI 13, CS 15
4#include <SPI.h>
5#include <SD.h>
6
7const int SD_CS = 5;
8const int ADC_CS = 15;
9
10SPIClass hspi(HSPI);                              // ikinci donanım SPI / second hardware SPI
11SPISettings mcpSettings(1000000, MSBFIRST, SPI_MODE0);
12
13int readMCP3008(byte channel) {
14  hspi.beginTransaction(mcpSettings);
15  digitalWrite(ADC_CS, LOW);
16  hspi.transfer(0x01);
17  byte high = hspi.transfer(0x80 | (channel << 4));
18  byte low = hspi.transfer(0x00);
19  digitalWrite(ADC_CS, HIGH);
20  hspi.endTransaction();
21  return ((high & 0x03) << 8) | low;
22}
23
24void setup() {
25  Serial.begin(115200);
26  pinMode(ADC_CS, OUTPUT);
27  digitalWrite(ADC_CS, HIGH);
28  hspi.begin(14, 12, 13, ADC_CS);                 // SCK, MISO, MOSI, SS
29
30  if (!SD.begin(SD_CS)) {                         // SD varsayılan VSPI'yi kullanır / SD uses the default VSPI
31    Serial.println("SD bulunamadi / SD not found");
32  }
33}
34
35void loop() {
36  int raw = readMCP3008(0);
37  File f = SD.open("/olcum.csv", FILE_APPEND);    // ekle kipinde aç / open in append mode
38  if (f) {
39    f.printf("%lu,%d\n", millis(), raw);
40    f.close();
41  }
42  Serial.printf("CH0: %d\n", raw);
43  delay(1000);
44}
GPIO 12, de MISO-pin van HSPI, is een van de boot-pinnen (strapping) van de ESP32: als hij bij het opstarten HIGH is, denkt het board dat de flash op 1,8 V draait en start het niet. Sluit geen modules met een pull-upweerstand op MISO (zoals de meeste SD-kaartmodules) aan op HSPI, of verplaats MISO naar een andere pin. Daarom zit de SD-kaart in dit voorbeeld op VSPI.

SPI met de Raspberry Pi Pico (MicroPython)

De Pico heeft twee hardware-SPI-eenheden (SPI0 en SPI1), die in MicroPython worden gebruikt via de klasse machine.SPI. De parameters polarity en phase komen overeen met CPOL en CPHA; als beide 0 zijn, is het modus 0. CS beheer je zelf als gewone outputpin. De functie write_readinto() toont het full-duplexkarakter van SPI het best: terwijl hij de ene array verstuurt, schrijft hij de binnenkomende bytes in een andere. Laten we dezelfde MCP3008 lezen, dit keer gevoed met 3,3 V:

MicroPython
1# Raspberry Pi Pico: SPI0 ile MCP3008 okuma / reading an MCP3008 on SPI0
2# GP18 -> CLK, GP19 -> DIN (MOSI), GP16 <- DOUT (MISO), GP17 -> CS. MCP3008 VDD ve VREF 3V3 / VDD and VREF on 3V3
3from machine import Pin, SPI
4import time
5
6spi = SPI(0, baudrate=1_000_000, polarity=0, phase=0,   # mod 0 / mode 0
7          sck=Pin(18), mosi=Pin(19), miso=Pin(16))
8cs = Pin(17, Pin.OUT, value=1)                          # başta seçili değil / not selected at start
9
10def read_mcp3008(channel):
11    tx = bytearray([0x01, 0x80 | (channel << 4), 0x00])
12    rx = bytearray(3)
13    cs.value(0)                                          # cihazı seç / select the chip
14    spi.write_readinto(tx, rx)                           # aynı anda gönder ve al / send and receive at once
15    cs.value(1)
16    return ((rx[1] & 0x03) << 8) | rx[2]
17
18while True:
19    raw = read_mcp3008(0)
20    print("CH0:", raw, "{:.2f} V".format(raw * 3.3 / 1023))
21    time.sleep(0.5)

SPI vs I2C vs UART

EigenschapSPII2CUART
Aantal draden4 (+1 CS voor elk extra apparaat)2 (SDA, SCL)2 (TX, RX)
Typische snelheid1–80 MHz100 kHz, 400 kHz, 1 MHz9600–115200 baud (tot een paar Mbit/s)
KlokJa (gegenereerd door de controller)Ja (gegenereerd door de controller)Geen; beide kanten spreken dezelfde baudrate af
RichtingFull duplexHalf duplexFull duplex
ApparaatselectieAparte CS-draad7-bitsadresSlechts twee apparaten (punt-tot-punt)
Extra onderdelenGeen nodigPull-upweerstandenGeen nodig
AfstandKort (op het board, enkele tientallen cm)Kort (rond 1 m)Enkele meters; veel langer met RS-485
Typische modulesSD-kaart, RC522, tft, nRF24L01, MAX7219OLED, I2C-lcd-backpack, RTC, BME280, MPU6050GPS, HC-05, SIM800L, ESP-01, computer

De keuze wordt meestal door de module bepaald, maar in je eigen ontwerpen helpt deze vuistregel: als snelheid en datavolume belangrijk zijn (displaybeelden, bestanden, audio), gebruik dan SPI; als je weinig draden en veel trage sensoren nodig hebt, gebruik dan I2C; als je een eenvoudige, tekstgebaseerde verbinding tussen twee apparaten wilt, gebruik dan UART. UART vind je uitgebreid in het artikel UART seriële communicatie. Alle drie in hetzelfde project gebruiken is ook heel gebruikelijk: bijvoorbeeld een datalogger die sensoren via I2C leest, via SPI naar een SD-kaart schrijft en zijn positie via UART van een GPS krijgt.

Modules die SPI gebruiken en projectideeën

  • Kaartslot en toegangslog: lees de kaart met een RC522 en schrijf de datum en UID naar een SD-kaart.
  • Temperatuurlogger: sla sensordata als csv op een microSD-kaart op en maak er een grafiek van in Excel.
  • Scrollend tekstbord: toon de tijd en berichten op in een daisy chain gekoppelde MAX7219-ledmatrixmodules.
  • Kleureninterface: teken afbeeldingen en menu's op een ILI9341 tft-display; sluit het touchpaneel ook op dezelfde SPI-bus aan.
  • Draadloze afstandsbediening: stuur commando's naar je robotauto met twee nRF24L01-modules.
  • Meerkanaalsmeting: bouw met een MCP3008 een MIDI-controller met 8 potmeters of een bewateringssysteem met 8 bodemvochtsensoren.

Veelgemaakte fouten en hoe je ze oplost

SymptoomWaarschijnlijke oorzaakOplossing
Leest steeds 0xFF of 0x00MISO niet aangesloten, MOSI en MISO verwisseld, of het apparaat heeft geen voedingSluit DIN aan op MOSI en DOUT op MISO; meet de VCC van het apparaat
Waarden zijn onzin of één bit verschovenVerkeerde SPI-modus of een te snelle klok voor het apparaatGebruik de modus uit de datasheet, verlaag de snelheid naar 1 MHz en probeer het opnieuw
Twee apparaten die apart werken, werken samen nietEen module laat MISO niet los, of de CS-pinnen zijn bij het opstarten niet HIGHZet eerst alle CS-pinnen HIGH; vervang de module die MISO niet loslaat of gebruik een aparte SPI-bus
SPI stopt plotseling op de UnoD10 werd als input gebruikt en LOW getrokkenLaat D10 een output; je kunt hem als CS gebruiken
ESP32 start niet op met HSPI aangeslotenGPIO 12 wordt bij het opstarten HIGH gehoudenVerplaats de MISO met pull-up naar VSPI of kies een andere pin voor MISO
Willekeurige fouten bij lange dradenReflecties en ruis op een snel signaalMaak de draden korter, verlaag de snelheid, leg een GND-draad naast de signalen
Een goedkope logic analyzer met 8 kanalen is bijzonder handig om te zien wat er op SPI gebeurt: hij registreert SCK, MOSI, MISO en CS tegelijk en decodeert welke byte eruit ging en welke terugkwam. Zodra je zegt "de code klopt maar het werkt niet", zie je binnen enkele seconden of het probleem in de bedrading of in de instellingen zit.

SPI is de gemeenschappelijke taal van de snelle modules in de Arduino-wereld, van SD-kaarten tot kleurendisplays: als je de vier draden, de CS-logica en de vier modi eenmaal kent, kost het aansluiten van een nieuwe SPI-module een paar minuten. In de BlueGrays-app vind je de projecten RFID-kaartlezer met deurslot, microSD-temperatuurlogger en MAX7219-puntmatrixklok, stap voor stap met schakelschema's en code.

Veelgestelde vragen

Waar staat SPI voor?

SPI staat voor Serial Peripheral Interface. Hiermee wisselt een controller snel en synchroon data uit met randapparaten via vier lijnen: SCK, MOSI, MISO en CS.

Wat zijn MOSI en MISO?

MOSI (Master Out Slave In) is de datalijn van de controller naar het randapparaat; MISO (Master In Slave Out) is de datalijn van het randapparaat terug naar de controller. In de nieuwere benaming heten ze ook COPI en CIPO. Op modules gaat DIN meestal naar MOSI en DOUT naar MISO.

Welke pinnen zijn de SPI-pinnen op de Arduino Uno?

Op de Arduino Uno en Nano is SCK D13, MISO D12, MOSI D11 en de standaard-CS D10. Dezelfde lijnen zitten ook op de 6-pins ICSP-header van het board. Op de Arduino Mega is SCK D52, MISO D50, MOSI D51 en CS D53.

Wat is het verschil tussen SPI en I2C?

SPI gebruikt vier draden, is full duplex en kan op tientallen MHz draaien; elk apparaat heeft een eigen CS-draad nodig. I2C gebruikt maar twee draden en selecteert apparaten via een adres, maar draait op veel lagere snelheden zoals 100–400 kHz en heeft pull-upweerstanden nodig.

Hoeveel apparaten kun je op één SPI-bus aansluiten?

Er is geen theoretische limiet; je hebt alleen voor elk apparaat een vrije CS-pin op de controller nodig. In de praktijk ontstaan er bij hoge snelheden problemen naarmate de buscapaciteit en de draadlengte toenemen. Als je pinnen tekortkomen, kun je de CS-lijnen vermenigvuldigen met een 74HC138-decoder of apparaten gebruiken die in een daisy chain kunnen worden gekoppeld.

Waarom werken een SD-kaart en een RFID-lezer niet op dezelfde SPI-bus?

De niveauconverter op veel goedkope SD-kaartmodules laat de MISO-lijn niet los, zelfs niet als CS HIGH is, en verstoort daardoor het antwoord van de RC522. Het oplossen kan met een module die MISO goed loslaat, door de enable-pin van de bufferchip aan CS te verbinden, of door de twee apparaten op de ESP32 op aparte SPI-bussen te zetten.

Alle projecten bekijken
RFID-waarde uitlezen
AR-53Beginner
Premium

RFID-waarde uitlezen

Je sleutelhanger of toegangskaart verbergt een geheim ID-nummer en dit project leest het uit. Houd de kaart bij de RFID-lezer en de Arduino schrijft het kaartnummer naar je computerscherm.

4.7(47)
61
RFID-authenticatie
AR-54Gemiddeld
Premium

RFID-authenticatie

Net als de kaartlezer bij een appartementsdeur: je houdt je kaart bij de RFID-lezer en de Arduino vergelijkt het nummer met het opgeslagen nummer.

4.8(65)
84
ESP32 RFID-RC522-kaartlezer (met LCD)
ES-21Gemiddeld

ESP32 RFID-RC522-kaartlezer (met LCD)

In dit project sluit je de RC522-RFID-module op basis van de MFRC522 via SPI aan op de ESP32 en lees je de UID van een kaart of tag uit. Dit vormt de basis voor toepassingen zoals deursloten, ledensystemen en toegangscontrole. De uitgelezen UID tonen we op een LCD; deze versie vergelijkt hem niet met een lijst van geautoriseerde kaarten. LET OP: de RC522 werkt alleen op 3,3 V; geef je hem 5 V, dan brandt de module door!

4.8(21)
42
ESP32 RFID-deurslot (RC522 + servo + OLED + buzzer + LED)
ES-35Gevorderd
Premium

ESP32 RFID-deurslot (RC522 + servo + OLED + buzzer + LED)

We bouwen een slim deurslot met een ESP32, een RC522 RFID-module, een SG90-servo, een SSD1306 OLED-display, een actieve buzzer en 2 leds. Bij het scannen van een kaart wordt de UID vergeleken met de geautoriseerde kaarten in de code; bij een match ontgrendelt de servo (groene led + 2 korte piepjes) en vergrendelt na 5 seconden weer. Een onbekende kaart laat de rode led branden, geeft 3 snelle piepjes en toont de UID op de OLED.

4.8(9)
16
ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Gevorderd
Premium

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)

Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.

4.7(7)
12
Dotmatrix-klok en -kalender (MAX7219, DS1307)
AR-84Gemiddeld
Premium

Dotmatrix-klok en -kalender (MAX7219, DS1307)

Een oplichtend bord voor op je bureau of aan de muur dat de tijd en de datum toont in scrollende tekst.

5.0(37)
59
4x 32x8-matrix ledanimatie en tekst
AR-90Gemiddeld
Premium

4x 32x8-matrix ledanimatie en tekst

Stapel vier lange ledmatrixmodules op elkaar en je krijgt een vierkant scherm met meer dan duizend lichtpunten. Eerst regenen er letters van boven naar beneden, zoals in de film.

4.6(40)
66
Pixelslang 8x8-matrix
AR-88Gevorderd
Premium

Pixelslang 8x8-matrix

Bouw het klassieke slangenspel zelf en speel het. Op een kleurrijke 8x8-lichtmatrix stuur je met een joystick een groene slang en eet je rode appels.

4.7(39)
57