Raspberry Pi Pico, dengan microcontroller RP2040 yang tangguh dan harga yang terjangkau, telah menjadi pilar utama bagi ribuan proyek elektronika dan embedded systems, dari yang sederhana hingga sangat kompleks. Kekuatan sejati Raspberry Pi Pico tidak hanya terletak pada inti prosesor dual-core-nya, tetapi pada kemampuannya yang luas untuk berinteraksi dengan dunia luar. Interaksi ini seperti membaca data dari sensor, mengontrol motor, menampilkan teks pada layar, atau berbicara dengan komputer dan hampir selalu membutuhkan komunikasi data.
Di sinilah tiga protokol fundamental muncul, yaitu I2C, SPI, dan UART. Ketiga komunikasi data ini adalah bahasa yang digunakan oleh chip-chip elektronik untuk "berbicara" satu sama lain. Memahami perbedaan mendalam antara ketiganya bukanlah hal yang akademis semata; itu adalah kebutuhan praktis untuk memilih alat yang tepat untuk pekerjaan yang tepat, mengoptimalkan kinerja sistem, dan memecahkan masalah yang pasti akan muncul.
Dasar-dasar Komunikasi Serial
1. Serial vs. Paralel
Komunikasi data terjadi dengan mengirimkan bit-bit (0 dan 1). Dalam komunikasi paralel, banyak bit (biasanya 8, 16, atau 32) dikirim secara bersamaan melalui banyak kabel (bus) secara paralel. Ini cepat tetapi membutuhkan banyak pin IC dan kabel, serta rentan terhadap masalah sinkronisasi dan interferensi pada jarak jauh. Komunikasi serial mengirimkan bit satu per satu, secara berurutan, melalui satu saluran (atau beberapa untuk duplexing). Ini lebih lambat per siklusnya tetapi jauh lebih efisien dalam hal penggunaan pin, biaya, dan reliabilitas untuk jarak menengah. I2C, SPI, dan UART adalah semua bentuk komunikasi serial.
2. Sinkron vs. Asinkron
- Komunikasi Sinkron (I2C & SPI): Memiliki saluran khusus untuk sinyal clock (SCL/SCK). Perangkat pengirim (master) menghasilkan clock yang berdenyut, dan setiap bit data dibaca atau ditulis pada edge clock yang spesifik (mis., naik atau turun). Clock ini menyinkronkan pengirim dan penerima, memastikan mereka beroperasi pada kecepatan yang sama persis. Ini memungkinkan kecepatan tinggi dan frame data yang panjang.
- Komunikasi Asinkron (UART): Tidak memiliki saluran clock. Sebaliknya, kedua perangkat harus sepakat sebelumnya pada kecepatan data yang sama (disebut baud rate, mis., 9600, 115200). Data dikirim dalam paket-paket pendek yang diawali dengan "Start Bit" dan diakhiri dengan "Stop Bit", yang membantu penerima menyinkronkan diri secara internal pada awal setiap paket. Lebih sederhana tetapi umumnya lebih lambat dan membutuhkan presisi baud rate.
3. Mode Transfer: Simplex, Half-Duplex, Full-Duplex
- Simplex: Komunikasi satu arah saja (seperti radio).
- Half-Duplex: Komunikasi dua arah, tetapi hanya satu arah pada satu waktu (seperti walkie-talkie). I2C adalah half-duplex.
- Full-Duplex: Komunikasi dua arah secara simultan (seperti percakapan telepon). SPI dan UART adalah full-duplex.
4. Voltage Logic
Raspberry Pi Pico beroperasi pada logika 3.3V. Sangat penting untuk memastikan bahwa perangkat yang Anda hubungkan juga kompatibel dengan 3.3V. Menghubungkan perangkat 5V langsung ke pin Pico dapat merusaknya. Gunakan level shifter atau converter logic jika diperlukan.
Dengan konsep ini dalam pikiran, mari kita bahas masing-masing protokol.
Tabel Perbandingan Komunikasi Data I2C, SPI, dan UART
I2C (Inter-Integrated Circuit)
1. Teori dan Arsitektur I2C
I2C, dibaca "I-squared-C" atau "I-two-C", adalah protokol komunikasi serial sinkron yang dirancang oleh Philips (sekarang NXP Semiconductors). Filosofi dasarnya adalah kesederhanaan dan minimalisme kabel. Hanya dua kabel yang dibutuhkan untuk menghubungkan puluhan perangkat.
Karakteristik Inti:
a. Dua Kabel:
1. SDA (Serial Data): Saluran untuk transfer data aktual.
2. SCL (Serial Clock): Saluran yang membawa sinyal clock yang dihasilkan master.
b. Sistem Multi-Master dan Multi-Slave
Secara teori, bisa memiliki lebih dari satu master, meskipun dalam praktiknya Raspberry Pi Pico hampir selalu bertindak sebagai master tunggal.
c. Addressing berbasis Perangkat
Setiap perangkat slave (seperti sensor, IC memori) memiliki alamat fisik 7-bit atau 10-bit yang unik (hardwired atau set melalui pin). Master mengalamati slave tertentu saat memulai komunikasi. Ruang alamat 7-bit memberikan 128 alamat unik (beberapa dicadangkan, sehingga sekitar 112可用).
d. Half-Duplex
Komunikasi terjadi dalam dua arah, tetapi hanya satu arah pada satu waktu pada saluran SDA yang sama.
e. Pull-Up Resistor
Kedua saluran SDA dan SCL adalah open-drain. Ini berarti perangkat dapat menarik garis ke LOW (0V), tetapi tidak dapat mendorongnya ke HIGH (3.3V). Untuk mengembalikan garis ke HIGH, diperlukan resistor pull-up eksternal (biasanya bernilai 4.7kΩ atau 10kΩ) yang terhubung ke VCC (3.3V). Beberapa modul sudah memiliki resistor ini, tetapi seringkali Anda perlu menambahkannya sendiri pada breadboard.
Cara Kerja Protokol:
Komunikasi I2C diawali dengan kondisi START, diakhiri dengan kondisi STOP, dan dikendalikan oleh master.
a. Condition START: Master menarik SDA dari HIGH ke LOW while SCL masih HIGH.
b. Pengiriman Address: Master mengirim alamat 7-bit slave target, diikuti oleh bit tunggal yang menunjukkan intent baca (1) atau tulis (0). Jika slave dengan alamat tersebut ada, ia akan merespons dengan ACK (Acknowledgment) bit dengan menarik SDA LOW.
c. Transfer Data: Master atau slave (tergantung mode) mulai mengirimkan data byte per byte. Setiap byte (8-bit) diikuti oleh ACK bit dari pihak penerima.
d. Condition STOP: Master membiarkan SDA naik dari LOW ke HIGH while SCL adalah HIGH.
Kelebihan I2C:
a. Hanya Dua Kabel: Menghemat pin yang berharga pada microcontroller, bahkan dengan banyak perangkat.
b. Mendukung Banyak Perangkat: Mudah untuk menambahkan sensor baru ke bus yang sama asalkan memiliki alamat unik.
c. Protokol yang Kokoh: Dengan bit ACK/NACK, master dapat mengetahui apakah slave telah menerima data.
d. Kecepatan Fleksibel: Standar (100 kbps), Fast (400 kbps), Fast-Mode Plus (1 Mbps), High-Speed (3.4 Mbps). Pico umumnya nyaman hingga 400 kbps.
Kekurangan I2C:
- Lebih Lambat dari SPI: Overhead protokol dan sifat half-duplex membatasi kecepatan maksimumnya.
- Memerlukan Resistor Pull-Up: Tambahan komponen eksternal.
- Masalah Kapasitansi: Jumlah slave yang banyak dapat meningkatkan kapasitansi bus, yang dapat menyebabkan bentuk gelombang membulat dan error komunikasi. Nilai resistor pull-up mungkin perlu disesuaikan.
- Address Conflict: Dua perangkat mungkin memiliki alamat yang sama, menyebabkan konflik. Beberapa IC memungkinkan untuk mengubah alamat dengan menghubungkan pin.
2. Implementasi I2C pada Raspberry Pi Pico
RP2040 memiliki dua hardware I2C yang dapat dialokasikan ke banyak pin yang berbeda.
Pinout I2C pada Pico:
a. I2C0 Default: GP0 (SDA), GP1 (SCL)
b. I2C1 Default: GP2 (SDA), GP3 (SCL)
c. Pin Alternatif: Hampir semua pin dapat dikonfigurasi untuk fungsi I2C, tetapi GP0/1 dan GP2/3 adalah yang paling umum digunakan.
Kode Contoh MicroPython: Membaca dari Sensor BMP280 (I2C)
from machine import Pin, I2C
import time
import struct
# Inisialisasi I2C0 pada GP0 (SDA) dan GP1 (SCL)
i2c = I2C(0, scl=Pin(1), sda=Pin(0), freq=400000) # 400 kHz
# Scan bus I2C untuk menemukan perangkat
devices = i2c.scan()
if devices:
for d in devices:
print("Alamat perangkat I2C ditemukan: ", hex(d))
else:
print("Tidak ada perangkat I2C ditemukan!")
# Alamat BMP280 biasanya 0x76 atau 0x77
BMP280_ADDR = 0x76
# ID Register untuk BMP280 (nilainya harus 0x58)
REG_ID = 0xD0
i2c.writeto(BMP280_ADDR, bytes([REG_ID]))
data = i2c.readfrom(BMP280_ADDR, 1)
print(f"ID Chip BMP280: {hex(data[0])}")
# Kalibrasi: Membaca koefisien kalibrasi (contoh untuk temperature)
REG_CALIB = 0x88
i2c.writeto(BMP280_ADDR, bytes([REG_CALIB]))
calib_data = i2c.readfrom(BMP280_ADDR, 24) # Membaca 24 byte data kalibrasi
# Unpack data kalibrasi (contoh, format little-endian signed short)
dig_T1 = struct.unpack('<H', calib_data[0:2])[0]
dig_T2 = struct.unpack('<h', calib_data[2:4])[0]
dig_T3 = struct.unpack('<h', calib_data[4:6])[0]
# ... proses serupa untuk koefisien tekanan
# Konfigurasi BMP280 untuk pengukuran
REG_CTRL_MEAS = 0xF4
# Set mode normal, oversampling temperature x1, pressure x1
i2c.writeto(BMP280_ADDR, bytes([REG_CTRL_MEAS, 0x27]))
def read_temp():
# Baca data ADC temperature (3 bytes) dari register 0xFA, 0xFB, 0xFC
REG_TEMP = 0xFA
i2c.writeto(BMP280_ADDR, bytes([REG_TEMP]))
adc_data = i2c.readfrom(BMP280_ADDR, 3)
adc_temp = (adc_data[0] << 12) | (adc_data[1] << 4) | (adc_data[2] >> 4)
# Proses kompensasi temperature yang sebenarnya (disingkat)
# ... (rumus kompensasi panjang dari datasheet BMP280)
var1 = (((adc_temp >> 3) - (dig_T1 << 1)) * dig_T2) >> 11
var2 = (((((adc_temp >> 4) - dig_T1) * ((adc_temp >> 4) - dig_T1)) >> 12) * dig_T3) >> 14
t_fine = var1 + var2
temperature = (t_fine * 5 + 128) >> 8
return temperature / 100.0
while True:
temp = read_temp()
print(f"Suhu: {temp:.2f} °C")
time.sleep(1)
Catatan: Rumus kompensasi lengkap bisa dilihat di datasheet BMP280.
SPI (Serial Peripheral Interface)
1. Teori dan Arsitektur SPI
SPI, yang diciptakan oleh Motorola, adalah protokol sinkron full-duplex yang sangat sederhana dan sangat cepat. Ia sering disebut sebagai protokol "four-wire".
Karakteristik Inti:
a. Empat Kabel (atau lebih):
1. MOSI (Master Out Slave In): Data dari master ke slave.
2. MISO (Master In Slave Out): Data dari slave ke master.
3. SCK (Serial Clock): Sinyal clock dari master.
4. CS/SS (Chip Select / Slave Select): Pin yang dipilih master untuk mengaktifkan slave tertentu. Ini adalah kunci untuk SPI. Setiap slave membutuhkan pin CS dedicated sendiri dari master.
b. Sistem Master-Slave: Hanya satu master (biasanya microcontroller).
c. Full-Duplex: Data dapat dikirim (pada MOSI) dan diterima (pada MISO) secara bersamaan.
d. Tidak Ada Addressing: Alamat perangkat tidak diperlukan. Sebaliknya, master memilih slave mana yang ingin diajak bicara dengan menarik pin CS slave tersebut ke LOW (active low). Jika pin CS HIGH, slave mengabaikan semua traffic pada bus SCK/MOSI.
e. Kecepatan Sangat Tinggi: Dapat dengan mudah mencapai puluhan MHz (pada Pico, hingga ~62.5 MHz pada kondisi ideal). Hanya dibatasi oleh kecepatan microcontroller dan panjang kabel.
Mode Clock (Polaritas dan Fase):
SPI memiliki empat mode operasi yang menentukan hubungan antara clock (SCK) dan data. Kedua perangkat harus diset ke mode yang sama.
a. CPOL (Clock Polarity): Status idle clock.
* CPOL=0: Clock idle LOW.
* CPOL=1: Clock idle HIGH.
b. CPHA (Clock Phase): Pada edge clock mana data disampling.
* CPHA=0: Data disampling pada edge clock pertama (leading edge).
* CPHA=1: Data disampling pada edge clock kedua (trailing edge).
Kombinasi ini menghasilkan 4 mode:
a. Mode 0: CPOL=0, CPHA=0 (paling umum)
b. Mode 1: CPOL=0, CPHA=1
c. Mode 2: CPOL=1, CPHA=0
d. Mode 3: CPOL=1, CPHA=1
Kelebihan SPI:
a. Kecepatan Sangat Tinggi: Protokol pilihan untuk aplikasi berkecepatan tinggi seperti layar LCD, memori SD card, ADC cepat.
b. Full-Duplex: Transfer data dua arah secara simultan.
c. Protokol Sederhana: Sangat sedikit overhead; hampir semua bit pada bus adalah data yang berguna.
d. Flexibilitas Data: Frame data bisa berapa pun panjangnya (tidak terbatas 8-bit).
Kekurangan SPI:
a. Banyak Kabel: Setiap slave tambahan membutuhkan pin CS dedicated baru dari master. Dengan banyak slave, Anda dapat kehabisan pin dengan cepat ("curse of Chip Select").
b. Tidak Ada Acknowledgment: Master tidak memiliki cara bawaan untuk mengetahui apakah slave benar-benar menerima data.
c. Tidak Ada Error Checking: Tidak ada checksum atau koreksi error bawaan.
d. Jarak Pendek: Dirancang untuk komunikasi on-board, bukan untuk jarak panjang.
2. Implementasi SPI pada Raspberry Pi Pico
RP2040 memiliki dua hardware SPI yang dapat dialokasikan ke banyak pin.
Pinout SPI pada Pico:
a. SPI0 Default: GP3 (CSn), GP4 (MOSI), GP5 (MISO), GP6 (SCK)
b. SPI1 Default: GP13 (CSn), GP11 (MOSI), GP12 (MISO), GP10 (SCK)
c. Pin Alternatif: Seperti I2C, pin SPI dapat dipetakan ke banyak lokasi.
Kode Contoh MicroPython: Berkomunikasi dengan SD Card Module (SPI)
from machine import Pin, SPI
import time, sdcard, os
# Inisialisasi SPI1 pada pin default
# GP10=SCK, GP11=MOSI, GP12=MISO, GP13=CS (kita gunakan pin terpisah untuk CS SD card)
spi = SPI(1, baudrate=1000000, polarity=0, phase=0, sck=Pin(10), mosi=Pin(11), miso=Pin(12))
sd_cs = Pin(13, Pin.OUT) # Pin Chip Select untuk SD card
# Inisialisasi objek SD card
sd = sdcard.SDCard(spi, sd_cs)
# Mount filesystem SD card sebagai /sd
vfs = os.VfsFat(sd)
os.mount(vfs, '/sd')
# Cek isi direktori root
print("Isi direktori root:", os.listdir('/'))
print("Isi direktori SD card:", os.listdir('/sd'))
# Buat dan tulis file pada SD card
with open('/sd/test.txt', 'w') as f:
f.write('Hello, SD Card World from Raspberry Pi Pico!\n')
f.write('Ini adalah test penyimpanan data.\n')
# Baca file dari SD card
with open('/sd/test.txt', 'r') as f:
content = f.read()
print("Isi file test.txt:")
print(content)
# Unmount SD card (opsional, untuk keamanan data)
# os.umount('/sd')
UART (Universal Asynchronous Receiver/Transmitter)
1. Teori dan Arsitektur UART
UART adalah salah satu protokol komunikasi serial tertua dan paling sederhana. Ia murni asinkron, yang berarti tidak memiliki clock. Ini membuatnya ideal untuk komunikasi antara dua perangkat tanpa kebutuhan koordinasi clock yang ketat, seperti dari microcontroller ke komputer via USB-to-Serial.
Karakteristik Inti:
a. Dua Kabel:
1. TX (Transmit): Pin untuk mengirim data.
2. RX (Receive): Pin untuk menerima data.
Koneksinya adalah silang: TX perangkat A terhubung ke RX perangkat B, dan RX perangkat A terhubung ke TX perangkat B.
c. Asinkron: Tidak ada sinyal clock.
d. Bergantung pada Baud Rate: Kedua perangkat harus diset ke kecepatan yang sama (baud rate) sebelumnya, mis., 9600, 19200, 115200 baud (bit per second). Ketidakcocokan baud rate akan menghasilkan data yang korup.
d. Format Frame Data: Data dikirim dalam paket yang disebut frame. Setiap frame berisi:
1. Start Bit: Selalu 1 bit LOW, memberi sinyal awal transmisi.
2. Data Payload: 5 hingga 9 bit data (biasanya 8 bit).
3. Parity Bit (Opsional): Bit untuk deteksi error sederhana (even or odd parity).
4. Stop Bit(s): 1 atau 2 bit HIGH, menandakan akhir frame.
e. Point-to-Point: UART dirancang untuk komunikasi antara tepat dua perangkat. Tidak seperti I2C atau SPI, ia tidak mendukung multiple slave pada bus yang sama.
Kelebihan UART:
a. Sangat Sederhana: Mudah diimplementasikan dalam perangkat lunak (bit-banging) jika diperlukan.
b. Hanya Dua Kabel: Untuk data (tidak termasuk ground).
c. Sudah Ditentukan: Didukung oleh hampir semua microcontroller dan komputer.
d. Dapat Menjadi Dasar Protokol Lain: Banyak protokol seperti MIDI, DMX, dan komunikasi modem berbasis AT menggunakan UART sebagai lapisan fisiknya.
Kekurangan UART:
a. Tidak Ada Master/Slave: Tidak ada mekanisme untuk mengontrol bus, yang dapat menyebabkan tabrakan jika tidak dikelola dengan baik di level yang lebih tinggi.
b. Tidak Efisien: Bit start, stop, dan parity adalah overhead yang mengurangi throughput data aktual.
c. Jarak Terbatas: Seperti SPI dan I2C, untuk jarak pendek. Untuk jarak longer, gunakan standard seperti RS-485 yang berbasis pada sinyal UART.
2. Implementasi UART pada Raspberry Pi Pico
RP2040 memiliki dua hardware UART (UART0 dan UART1).
Pinout UART pada Pico:
a. UART0 Default: GP0 (TX), GP1 (RX)
b. UART1 Default: GP4 (TX), GP5 (RX)
c. Pin Alternatif: UART dapat dipetakan ke banyak pin lainnya.
Kode Contoh MicroPython: Komunikasi Dua Pico dan ke Komputer
Contoh 1: Pico ke Komputer (via USB Serial)
from machine import UART, Pin
import time
# UART0 biasanya digunakan untuk REPL/debug ke USB.
# Jadi kita gunakan UART1 untuk komunikasi external.
# TX pada GP4, RX pada GP5
uart = UART(1, baudrate=9600, tx=Pin(4), rx=Pin(5))
counter = 0
while True:
uart.write('Hello, Computer! Counter = {}\r\n'.format(counter))
time.sleep(1)
counter += 1
# Cek jika ada data yang diterima
if uart.any():
data = uart.read()
print("Diterima:", data)
Contoh 2: Komunikasi antara Dua Raspberry Pi Pico
a. Pico A (Pengirim)
from machine import UART, Pin
import time
uart = UART(0, baudrate=115200, tx=Pin(0), rx=Pin(1)) # Gunakan UART0 pada GP0/GP1
while True:
uart.write("Ping from Pico A!\n")
time.sleep(0.5)
if uart.any():
response = uart.read()
print("Pico A received:", response)
b. Pico B (Penerima & Echo)
from machine import UART, Pin
import time
uart = UART(0, baudrate=115200, tx=Pin(0), rx=Pin(1)) # Gunakan UART0 pada GP0/GP1
while True:
if uart.any():
data = uart.read()
print("Pico B received:", data)
# Echo data kembali ke Pico A
uart.write(b"Echo: " + data)
Baca juga: Teori Transfer Data Sinkron dan Asinkron pada Raspberry Pi Pico
Siap Untuk Membuat Proyek Impianmu Menjadi Kenyataan?
Klik di sini untuk chat langsung via WhatsApp dan dapatkan dukungan langsung dari tim ahli kami!
0 on: "Perbedaan I2C, SPI, dan UART: Komunikasi Data di Raspberry Pi Pico"