Handshaking di Raspberry Pi Pico: Teori dan Implementasi dalam Komunikasi Data

Dalam dunia elektronik dan komputasi, komunikasi data yang andal adalah pilar utama dari hampir semua sistem embedded. Raspberry Pi Pico, dengan mikrokontroler RP2040 yang tangguh, menjadi papan pengembangan yang sangat populer untuk membangun berbagai proyek, mulai dari yang sederhana hingga sistem yang kompleks. Namun, dalam komunikasi antar perangkat, terutama yang berjalan pada kecepatan berbeda atau dengan timing yang tidak pasti, masalah seperti kehilangan data atau overflow buffer sering kali terjadi. Di sinilah konsep handshaking berperan penting sebagai protokol penjaga gerbang yang memastikan transfer data berlangsung mulus dan tanpa kesalahan. Artikel ini akan membahas teori dasar handshaking dan memberikan panduan implementasi praktisnya pada Raspberry Pi Pico.

Konsep Dasar Handshaking

 

Handshaking adalah proses protokol komunikasi di mana dua perangkat yang terhubung saling bertukar sinyal kontrol untuk menegaskan kesiapan mereka dalam mengirim, menerima, dan memproses data. Bayangkan dua orang yang sedang melakukan percakapan sopan. Sebelum berbicara, seseorang mungkin melakukan kontak mata atau mengangguk untuk memastikan lawan bicaranya sedang mendengarkan. Jika lawan bicara sibuk, dia akan memberi isyarat untuk menunggu. Handshaking dalam elektronik bekerja dengan prinsip yang serupa.

Tujuan Utama Handshaking

1.  Mengontrol Aliran Data (Flow Control): Mencegah pengirim dari membanjiri penerima dengan data saat penerima belum siap, sehingga menghindari kehilangan data akibat buffer overflow.

2.  Sinkronisasi: Menyelaraskan timing antara dua perangkat yang mungkin memiliki kecepatan pemrosesan atau clock yang berbeda.

3.  Menegaskan Koneksi: Memastikan bahwa kedua perangkat aktif dan berfungsi dengan baik sebelum pertukaran data dimulai.

 

Jenis-jenis Handshaking

 

1.  Hardware Handshaking: Menggunakan jalur sinyal fisik (pin GPIO khusus) selain jalur data untuk mengontrol aliran. Metode ini sangat cepat, efisien, dan mengurangi overhead pada perangkat lunak. Contoh standar yang umum adalah protokol RTS (Request To Send) dan CTS (Clear To Send).

2.  Software Handshaking: Menggunakan karakter khusus (seperti XON/XOFF) yang dikirim melalui jalur data yang sama untuk mengontrol aliran. Meskipun lebih sederhana dalam hal kabel karena membutuhkan lebih sedikit pin, metode ini menambah overhead pada data dan kurang cepat dibandingkan hardware handshaking.

 

Protokol Hardware Handshaking: RTS dan CTS

 

Salah satu implementasi hardware handshaking yang paling umum adalah menggunakan sinyal RTS (Request To Send) dan CTS (Clear To Send). Protokol ini banyak digunakan dalam komunikasi serial (UART). Secara standar, RTS adalah sinyal yang dikeluarkan pengirim untuk meminta izin mengirim, dan CTS adalah sinyal balasan dari penerima yang menunjukkan kesiapan menerima data. Namun, pada implementasi Raspberry Pi Pico dengan MicroPython di bawah ini, peran RTS/CTS disederhanakan: Pico B (Receiver) mengendalikan RTS, lalu Pico A (Sender) mendeteksi CTS HIGH dan masuk ke mode tunggu, sehingga pengiriman dijeda. Hal ini tidak persis sama dengan definisi standar UART, tetapi cukup efektif untuk praktik handshaking sederhana.

 

Mengapa Handshaking Penting untuk Raspberry Pi Pico?

 

Raspberry Pi Pico memiliki memori yang terbatas (264 KB RAM). Saat menerima data serial, data tersebut disimpan dalam buffer memori sementara. Jika data dikirim secara terus-menerus tanpa henti (misalnya, dari komputer yang powerful), buffer pada Pico dapat dengan mudah penuh dan meluap, menyebabkan kehilangan byte data. Handshaking memberikan mekanisme kepada Pico untuk "memberi tahu" pengirim untuk berhenti sejenak saat buffernya hampir penuh, lalu memberi isyarat untuk melanjutkan lagi setelah buffer kosong. Ini sangat kritis dalam aplikasi seperti:

- Pengumpulan data sensor berkecepatan tinggi.

- Komunikasi dengan modul GSM/GPS.

- Transfer file atau firmware update.

- Antarmuka dengan printer atau perangkat lama yang lambat.

 

Implementasi Hardware Handshaking pada Raspberry Pi Pico

 

Mari kita implementasikan hardware handshaking antara dua Raspberry Pi Pico menggunakan MicroPython. Kita akan menyambungkan dua Pico melalui UART dan dua pin GPIO tambahan untuk RTS/CTS.

Komponen yang Diperlukan:

- 2x Raspberry Pi Pico

- Kabel jumper (minimal 4 kabel)

Wiring Diagram:

- UART0 TX (GP0) Pico A (Sender) -> UART1 RX (GP9) Pico B (Receiver)

- UART1 TX (GP8) Pico B (Receiver) -> UART0 RX (GP1) Pico A (Sender)

- CTS (GP2) Pico A (Sender) -> RTS (GP3) Pico B (Receiver)

- GND Pico A -> GND Pico B

Kode MicroPython untuk Pico B (Receiver):

Pico B akan menerima data dan menggunakan pin RTS untuk mengontrol aliran berdasarkan kondisi buffernya.

 

# Receiver Code (Pico B)

from machine import Pin, UART

import time

# Inisialisasi UART1 pada GP8 (TX) dan GP9 (RX)

uart = UART(1, baudrate=115200, tx=Pin(8), rx=Pin(9))

# Inisialisasi Pin RTS (Output untuk Pico B, terhubung ke CTS Sender)

rts = Pin(3, Pin.OUT)

rts.value(0)  # LOW = siap menerima data

buffer_size = 200

data_buffer = []

def process_buffer():

    """Fungsi simulasi pemrosesan data lambat"""

    global data_buffer

    print("Memproses data dalam buffer...")

    time.sleep(2)  # Delay simulasi pemrosesan

    print(f"Data yang diproses: {''.join(data_buffer)}")

    data_buffer = []  # Kosongkan buffer

    print("Buffer kosong. RTS=0 (SIAP menerima lagi).")

    rts.value(0)

print("Pico B - Receiver siap. Menunggu data...")

try:

    while True:

        if uart.any():

            incoming_data = uart.read()

            if incoming_data:

                try:

                    decoded = incoming_data.decode('utf-8', errors='ignore')

                except:

                    decoded = ""

                if decoded:

                    # Simpan per karakter agar level buffer akurat

                    data_buffer.extend(list(decoded))

                    print(f"Data masuk: {decoded}")

                    current_buffer_load = len(data_buffer)

                    print(f"Level Buffer: {current_buffer_load}/{buffer_size}")

                    # Buffer hampir penuh → stop pengirim

                    if current_buffer_load >= buffer_size * 0.8:

                        print("Buffer hampir penuh! RTS=1 (STOP).")

                        rts.value(1)

                    # Jika buffer penuh → proses

                    if current_buffer_load >= buffer_size:

                        process_buffer()

        elif data_buffer:

            # Jika ada data tapi belum penuh, tetap proses setelah jeda

            time.sleep(0.5)

            process_buffer()

except KeyboardInterrupt:

    print("Program dihentikan.")

Catatan: Dalam aplikasi nyata, process_buffer() dapat diganti dengan logika pemrosesan sebenarnya, seperti menulis ke SD card atau parsing data sensor.

Kode MicroPython untuk Pico A (Sender):

Pico A akan mengirim data dan memeriksa pin CTS sebelum mengirim untuk memastikan receiver siap.

 

# Sender Code (Pico A)

from machine import Pin, UART

import time

# Inisialisasi UART0 pada GP0 (TX) dan GP1 (RX)

uart = UART(0, baudrate=115200, tx=Pin(0), rx=Pin(1))

# Inisialisasi Pin CTS (Input untuk Pico A, terhubung ke RTS Receiver)

cts = Pin(2, Pin.IN)

data_to_send = "HelloWorld1234567890abcdefghijklmnopqrstuvwxyz! "

data_index = 0

chunk_size = 5   # kirim 5 byte sekaligus

timeout = 5      # detik

print("Pico A - Sender siap. Memulai transmisi...")

try:

    while True:

        # Tunggu sampai receiver siap (CTS LOW)

        start = time.time()

        while cts.value() == 1:  # Receiver STOP

            if time.time() - start > timeout:

                print("Timeout! Receiver tidak merespons CTS.")

                break

            print("CTS HIGH (STOP). Menunggu...")

            time.sleep(0.1)

        # Kirim blok data

        chunk = data_to_send[data_index:data_index+chunk_size]

        data_index = (data_index + chunk_size) % len(data_to_send)

        uart.write(chunk)

        print(f"Data terkirim: {chunk}")

        time.sleep(0.05)  # jeda singkat antar blok

except KeyboardInterrupt:

    print("Program dihentikan.")

 

Catatan: Timeout ini mencegah pengirim menunggu tanpa batas jika penerima tidak pernah mengirim CTS=LOW.

Penjelasan Alur Implementasi: 

1.  Kondisi Awal: Receiver (Pico B) mengatur pin RTS-nya ke LOW (0), menandakan "Clear To Send".

2.  Pengiriman Data: Sender (Pico A) terus-menerus memeriksa pin CTS. Karena terhubung ke RTS Pico B yang LOW, CTS juga LOW, sehingga Sender bebas mengirim data.

3.  Buffer Hampir Penuh: Saat buffer di Pico B terisi hingga 80%, Pico B mengatur pin RTS-nya menjadi HIGH (1). Ini membuat pin CTS pada Sender menjadi HIGH.

4.  Pengiriman Dijeda: Sender mendeteksi CTS HIGH, lalu berhenti mengirim (masuk ke loop tunggu) hingga CTS kembali LOW.

5.  Pemrosesan Buffer: Pico B memproses data dalam buffernya (disimulasikan dengan time.sleep(2)), lalu mengosongkannya.

6.  Transmisi Dilanjutkan: Setelah buffer kosong, Pico B mengatur RTS kembali ke LOW (0). Sender mendeteksi perubahan CTS menjadi LOW dan secara otomatis melanjutkan pengiriman data.

 

Implementasi Software Handshaking pada Raspberry Pi Pico

 

Software handshaking lebih sederhana dari segi hardware karena hanya membutuhkan jalur TX dan RX. Kita akan menggunakan karakter kontrol XON (0x11) dan XOFF (0x13).

Kode untuk Pico B (Receiver dengan Software Flow Control):

from machine import UART, Pin

import time

uart = UART(1, baudrate=115200, tx=Pin(8), rx=Pin(9))

XON = b'\x11'

XOFF = b'\x13'

buffer = []

BUFFER_LIMIT = 50

print("Receiver Software Handshaking siap.")

while True:

    if uart.any():

        data = uart.read(1)  # Baca satu byte

        if data == XON or data == XOFF:

            # Abaikan karakter kontrol yang masuk

            continue

            

        buffer.append(data.decode())

        print(f"Terima: {data.decode()}, Buffer: {len(buffer)}/{BUFFER_LIMIT}")

        

        # Jika buffer mendekati penuh, kirim XOFF

        if len(buffer) > BUFFER_LIMIT * 0.8:

            print("Kirim XOFF")

            uart.write(XOFF)

            

        # Jika buffer kosong setelah penuh, kirim XON

        elif len(buffer) < BUFFER_LIMIT * 0.2:

            print("Kirim XON")

            uart.write(XON)

Catatan: Pada contoh ini, karakter XON/XOFF yang diterima diabaikan. Namun, dalam implementasi nyata, protokol ini hanya digunakan satu arah: receiver mengirim XON/XOFF, sender menaatinya.

Kode untuk Pico A (Sender dengan Software Flow Control):

from machine import UART, Pin

import time

uart = UART(0, baudrate=115200, tx=Pin(0), rx=Pin(1))

XON = b'\x11'

XOFF = b'\x13'

flow_status = True  # True = XON (bisa kirim), False = XOFF (berhenti)

def check_messages():

    global flow_status

    if uart.any():

        msg = uart.read(1)

        if msg == XOFF:

            flow_status = False

            print("Terima XOFF, berhenti mengirim.")

        elif msg == XON:

            flow_status = True

            print("Terima XON, lanjut mengirim.")

data_stream = "A"

print("Sender Software Handshaking siap.")

while True:

    check_messages() # Selalu periksa incoming message

    

    if flow_status:

        uart.write(data_stream)

        print(f"Kirim: {data_stream}")

        time.sleep(0.1)

Catatan: Kelemahan software handshaking adalah XON/XOFF bisa berbenturan dengan data asli jika data berisi semua kemungkinan byte (misalnya file biner). Untuk teks biasa umumnya aman.

 

Dengan memahami dan mengimplementasikan handshaking, baik hardware maupun software, proyek Raspberry Pi Pico Anda akan memiliki fondasi komunikasi data yang jauh lebih robust dan andal. Teknik ini adalah keterampilan essential untuk para maker dan engineer yang ingin membangun sistem embedded yang profesional dan bebas dari error data.

 

Baca juga: Keamanan Dasar Raspberry Pi Pico dalam Komunikasi Data: Panduan untuk Pemula

 

 

 

 

 

 

 

 

Siap Untuk Membuat Proyek Impianmu Menjadi Kenyataan?

Klik di sini untuk chat langsung via WhatsApp dan dapatkan dukungan langsung dari tim ahli kami!