Apa Itu SPI? Penjelasan Pin MOSI, MISO, SCK, dan CS untuk Arduino

SPI (Serial Peripheral Interface) adalah metode komunikasi yang memungkinkan mikrokontroler bertukar data dengan sangat cepat dengan perangkat seperti kartu SD, pembaca RFID, layar TFT berwarna, atau modul nirkabel lewat empat kabel. Ada jalur clock (SCK), dua jalur terpisah untuk data di masing-masing arah (MOSI dan MISO), dan jalur CS yang memilih perangkat mana yang sedang diajak bicara. Karena bisa puluhan kali lebih cepat daripada I2C, SPI menjadi bus pilihan untuk modul yang memindahkan data dalam jumlah besar.

Di artikel ini kamu akan belajar cara kerja SPI, nama-nama pin dan penamaan barunya, empat mode SPI, batas kecepatan, pin di Arduino Uno, Mega, ESP32 (VSPI dan HSPI), dan Raspberry Pi Pico, cara menghubungkan beberapa perangkat ke bus yang sama, dan kenapa kartu SD dan pembaca RFID RC522 bermasalah kalau dipakai bersama. Di bagian terakhir kita membandingkan SPI dengan I2C dan UART.

Apa itu SPI dan bagaimana cara kerjanya?

SPI selalu punya satu controller (dulu disebut master) dan satu atau lebih periferal (dulu disebut slave). Hanya controller yang membangkitkan clock; dengan kata lain, Arduino yang memulai percakapan, menentukan kecepatannya, dan mengakhirinya. Pada setiap pulsa clock, controller mengirim satu bit di MOSI dan pada momen yang sama periferal mengirim balik satu bit di MISO. Shift register di kedua sisi membentuk semacam cincin: setelah 8 pulsa clock, byte milik controller sudah pindah ke periferal dan byte milik periferal ke controller. Karena itu SPI bersifat full duplex: membaca dan menulis terjadi bersamaan.

Label di modul tidak selalu sama, dan inilah sumber kebingungan terbesar. Di modul RFID RC522, jalur CS diberi label SDA (tidak ada hubungannya dengan SDA milik I2C), di nRF24L01 namanya CSN, di MCP3008 CS/SHDN, dan di beberapa layar kamu akan melihat nama seperti DIN (MOSI), CLK (SCK), dan DOUT (MISO). Aturannya sederhana: input data (DIN, SDI, MOSI) masuk ke MOSI Arduino dan output data (DOUT, SDO, MISO) masuk ke MISO Arduino.

1. Controller menarik jalur CS perangkat yang ingin diajak bicara ke LOW. Semua perangkat lain menjaga CS-nya tetap HIGH dan melepaskan jalur MISO.
2. Controller mulai membangkitkan pulsa clock di SCK.
3. Pada setiap pulsa, satu bit keluar lewat MOSI dan satu bit masuk lewat MISO. Urutan bit biasanya dimulai dari bit paling signifikan (MSB first).
4. Setelah jumlah byte yang dibutuhkan (perintah, alamat, data) selesai dipindahkan, controller mengembalikan CS ke HIGH dan perangkat menyelesaikan operasinya.

Mode SPI: CPOL dan CPHA

SPI tidak punya satu standar tunggal; perangkat berbeda-beda dalam level clock ketika diam (CPOL, clock polarity) dan tepi clock tempat data dibaca (CPHA, clock phase). Empat kombinasi dari dua pengaturan ini membentuk empat mode SPI. Kalau controller dan perangkat tidak berada di mode yang sama, data bergeser satu bit dan kamu membaca nilai yang tidak bermakna. Untungnya, sebagian besar modul memakai Mode 0.

Kecepatan SPI dan panjang kabel

Di SPI, controller yang menentukan kecepatan, dan batasnya biasanya ada di perangkat itu sendiri. Arduino Uno bisa sampai 8 MHz, setengah dari clock 16 MHz-nya; bawaan library SPI adalah 4 MHz. ESP32 bisa membangkitkan sampai 80 MHz di pin SPI khususnya (IO_MUX), dan batasnya turun ketika sinyal diarahkan ke pin lain lewat GPIO matrix. Raspberry Pi Pico bisa mencapai sekitar 62,5 MHz dengan clock sistem 125 MHz. Sinyal SPI yang cepat butuh kabel pendek: dengan breadboard dan kabel jumper 10–20 cm, beberapa MHz tidak masalah; di 20–30 MHz ke atas, buat kabel sependek mungkin dan pakai sambungan solder kalau bisa. Panjang beberapa meter tidak cocok untuk SPI.

Pin SPI: Arduino Uno, Mega, ESP32, dan Raspberry Pi Pico

Di Uno, jalur SPI yang sama juga ada di header ICSP 6 pin di tepi board; di board seperti Leonardo dan Micro, SPI hanya tersedia di ICSP. D10 tidak wajib dipakai untuk CS; kamu bisa memakai pin digital mana saja. Namun, di Uno jangan biarkan D10 sebagai input: kalau hardware SPI membaca LOW di D10 ketika pin itu berupa input, ia keluar dari mode controller. SPI.begin() otomatis menjadikan pin ini output, dan jangan kamu ubah menjadi input untuk tugas lain. Di ESP32, objek SPI Arduino memakai VSPI secara bawaan; berkat GPIO matrix, kamu juga bisa memindahkan SPI ke hampir semua pin yang kamu mau. Di Pico, SPI0 dan SPI1 bisa ditempatkan di beberapa kelompok pin yang berbeda (misalnya GP10, GP11, GP12 untuk SPI1); lihat alat Pinout untuk detailnya.

Library SPI Arduino: fungsi dasar

Contoh pertama: mengirim data ke 74HC595 lewat SPI

Cara termudah memahami SPI adalah dengan shift register 74HC595, karena 595 sebenarnya adalah periferal SPI paling sederhana, yang tidak punya MISO. Pin MOSI Arduino masuk ke input DS milik 595, SCK ke SH_CP, dan D10 ke ST_CP yang berfungsi sebagai latch. Berbeda dengan fungsi shiftOut(), hardware SPI mengirim byte dalam beberapa mikrodetik:

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}

Membaca data lewat SPI: ADC MCP3008

Untuk melihat komunikasi full duplex, kita pakai MCP3008. Chip ini menambahkan 8 input analog 10-bit lagi ke Arduino; ini alternatif yang bagus untuk ADC ESP32 yang tidak linier atau Pico yang hanya punya 3 input analog. Dasar-dasar pembacaan analog sudah kami bahas di artikel Apa Itu ADC?. Pengkabelan: CLK → D13, DOUT → D12, DIN → D11, CS → D10, VDD dan VREF → 5V, AGND dan DGND → GND.

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}

Di sini kita mengirim tiga byte dan menerima tiga byte bersamaan. Byte pertama (0x01) hanya bit start; byte kedua membawa mode single-ended dan nomor kanal, sementara MCP3008 mengirim balik 2 bit teratas dari hasilnya. Byte ketiga adalah 0x00; isinya tidak penting, byte ini hanya dikirim untuk membangkitkan pulsa clock dan menerima 8 bit sisa hasilnya. Di SPI, “membaca” selalu berarti mengirim sesuatu. Hasilnya antara 0 dan 1023 dan diubah ke volt relatif terhadap VREF (di sini 5 V).

Beberapa perangkat SPI: jalur CS terpisah

Perbedaan terbesar SPI dari I2C adalah SPI tidak memakai alamat. Perangkat-perangkat berbagi jalur SCK, MOSI, dan MISO, dan masing-masing mendapat kabel CS sendiri dari Arduino. Hanya perangkat yang CS-nya LOW yang mendengarkan, dan hanya perangkat itu yang menulis data ke MISO. Tiga perangkat butuh 3 + 3 = 6 kabel, lima perangkat 3 + 5 = 8 kabel; jumlah pin bertambah seiring jumlah perangkat. Beberapa chip seperti 74HC595 dan MAX7219 bisa dirangkai berantai (daisy-chain) sebagai gantinya: output satu chip masuk ke input chip berikutnya dan semuanya digerakkan dengan satu CS.

• Hanya satu CS yang boleh LOW pada satu waktu. Kalau dua perangkat terpilih bersamaan, keduanya bertabrakan di jalur MISO dan kamu membaca data rusak dari keduanya.
• Di setup(), jadikan dulu setiap pin CS sebagai output dan tarik ke HIGH, baru setelah itu jalankan library-nya. Pin CS yang mengambang bisa secara acak terbaca LOW dan merebut bus.
• Pakai beginTransaction untuk setiap perangkat. Kartu SD mungkin mau 25 MHz dan MCP3008 1 MHz; transaksi menerapkan kecepatan dan mode yang benar secara otomatis di setiap peralihan.
• Kalau kamu memakai SPI di dalam interrupt, beri tahu library dengan SPI.usingInterrupt(), atau jangan lakukan pekerjaan SPI di dalam interrupt.
• Menambahkan pull-up 10 kΩ di jalur CS setiap perangkat mencegah perangkat memilih dirinya sendiri ketika Arduino sedang boot atau reset.

Kartu SD dan RFID di bus yang sama: kenapa tidak jalan?

Pertanyaan klasik di forum Arduino: RFID RC522 bekerja kalau sendirian, modul kartu SD bekerja kalau sendirian, tetapi ketika keduanya ada di bus SPI yang sama, salah satu atau keduanya diam. Bahkan ketika pin CS sudah benar di software, masalahnya biasanya ada di hardware. Banyak modul kartu SD murah punya chip buffer 74LVC125 yang mengubah sinyal 5 V menjadi 3,3 V, dan kanal chip ini yang menggerakkan jalur MISO selalu aktif. Jadi, bahkan ketika CS kartu SD HIGH, modul tidak melepaskan MISO; ketika RC522 mencoba menjawab, jalur itu diperebutkan oleh dua output.

• Pilih modul yang tepat: modul yang membuat MISO berimpedansi tinggi ketika CS HIGH bisa berbagi bus tanpa masalah. Untuk tahu apakah sebuah modul melepaskan jalurnya, tarik MISO lewat 10 kΩ ke GND lalu ke 5 V dengan CS HIGH, dan ukur dengan multimeter.
• Hubungkan pin enable buffer ke CS: kalau kamu sudah terbiasa menyolder, mengangkat pin OE kanal MISO pada 74LVC125 dari GND lalu menyambungkannya ke jalur CS modul akan membereskan masalah ini untuk selamanya.
• Tambahkan resistor seri di MISO: memasang resistor seri sekitar 1 kΩ di output MISO modul SD membuat RC522 bisa mengalahkan jalur itu. Ini solusi darurat yang mudah tetapi membatasi kecepatan.
• Pakai bus SPI terpisah: di ESP32, kalau kartu SD kamu sambungkan ke VSPI dan RC522 ke HSPI, kedua perangkat tidak pernah bertemu. Uno tidak punya SPI hardware kedua, jadi pilihan ini tidak ada di sana.
• Perhatikan urutan start: pertama jadikan semua pin CS HIGH, lalu panggil SPI.begin(), lalu SD.begin() dan PCD_Init(). Contoh di bawah mengikuti urutan ini.

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}

Di kode ini, library SD dan library MFRC522 menjadikan pin CS-nya masing-masing LOW dan HIGH sendiri; yang perlu kamu lakukan hanya membiarkan keduanya HIGH di awal dan memastikan hardware berbagi MISO dengan benar. Kode ini menulis UID setiap kartu yang dipindai, bersama timestamp, ke file kartlar.txt (nama file bahasa Turki untuk “kartu-kartu”). Di Uno, kedua library ini bersama-sama memakai sekitar setengah RAM; makro F() menghemat ruang dengan menyimpan teks konstan di flash.

VSPI dan HSPI di ESP32: dua bus SPI terpisah

ESP32 punya empat unit SPI di dalamnya; SPI0 dan SPI1 dipakai khusus untuk memori flash internal, sehingga tersisa VSPI (SPI3) dan HSPI (SPI2) untukmu. Memakai keduanya adalah cara paling rapi untuk memisahkan perangkat dengan kecepatan dan mode yang sangat berbeda atau untuk menghindari bentrok MISO di atas. Di core Arduino, kamu membuat objek SPIClass untuk bus kedua dan memberinya pin dengan begin(). Kode di bawah menjalankan kartu SD di VSPI bawaan dan MCP3008 di HSPI, lalu menambahkan satu pembacaan ke file CSV setiap detik:

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}

SPI dengan Raspberry Pi Pico (MicroPython)

Pico punya dua unit SPI hardware (SPI0 dan SPI1), yang di MicroPython dipakai lewat kelas machine.SPI. Parameter polarity dan phase sesuai dengan CPOL dan CPHA; kalau keduanya 0, itu Mode 0. CS kamu atur sendiri sebagai pin output biasa. Fungsi write_readinto() paling baik menunjukkan sifat full duplex SPI: sambil mengirim satu array, ia menulis byte yang masuk ke array lain. Kita baca MCP3008 yang sama, kali ini dengan daya 3,3 V:

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)

Perbandingan SPI vs I2C vs UART

Pilihannya biasanya ditentukan oleh modul, tetapi di desainmu sendiri aturan ini membantu: kalau kecepatan dan volume data penting (gambar di layar, file, audio), pakai SPI; kalau kamu butuh sedikit kabel dan banyak sensor lambat, pakai I2C; kalau kamu mau koneksi sederhana berbasis teks di antara dua perangkat, pakai UART. Penjelasan lengkap UART ada di artikel Komunikasi Serial UART. Memakai ketiganya di proyek yang sama juga sangat umum: misalnya data logger yang membaca sensor lewat I2C, menulis ke kartu SD lewat SPI, dan mengambil posisi dari GPS lewat UART.

Modul yang memakai SPI dan ide proyek

• Kunci pintu berkartu dan log akses: baca kartu dengan RC522 lalu tulis tanggal dan UID ke kartu SD.
• Pencatat suhu: rekam data sensor ke kartu microSD sebagai CSV lalu buat grafiknya di Excel.
• Papan teks berjalan: tampilkan jam dan pesan di modul LED matrix MAX7219 yang dirangkai berantai.
• Antarmuka berwarna: gambar grafik dan menu di layar TFT ILI9341; sambungkan juga panel sentuhnya ke bus SPI yang sama.
• Remote nirkabel: kirim perintah ke mobil robotmu dengan dua modul nRF24L01.
• Pengukuran multikanal: buat controller MIDI dengan 8 potensiometer atau sistem penyiraman dengan 8 sensor kelembapan tanah memakai MCP3008.

Kesalahan umum dan cara memperbaikinya

SPI adalah bahasa bersama modul-modul cepat di dunia Arduino, dari kartu SD sampai layar berwarna: begitu kamu memahami empat kabel, logika CS, dan empat mode, menyambungkan modul SPI baru hanya butuh beberapa menit. Di aplikasi BlueGrays kamu bisa menemukan proyek membaca kartu RFID dan kunci pintu, pencatat suhu microSD, serta jam dot matrix MAX7219, langkah demi langkah lengkap dengan skema rangkaian dan kode.