Apa Itu UART? Panduan Pengkabelan TX/RX, Baud Rate, dan Serial Arduino

Jawaban singkat untuk apa itu UART: UART (Universal Asynchronous Receiver-Transmitter) adalah perangkat keras komunikasi serial yang memungkinkan dua perangkat bertukar data byte demi byte melalui hanya dua kabel data (TX dan RX) ditambah GND bersama. Setiap baris yang kamu lihat di Serial Monitor ketika Arduino-mu terhubung ke komputer tiba melalui UART. Puluhan modul, seperti penerima GPS, modul Bluetooth HC-05, modul Wi-Fi ESP-01, modul GSM SIM800L, pembaca sidik jari, dan pemutar MP3, juga berkomunikasi dengan Arduino melalui UART.

Dalam artikel ini, kita membahas langkah demi langkah mengapa UART tidak memerlukan jalur clock, apa itu baud rate, bagaimana sebuah byte dibingkai dengan bit start, data, dan stop, mengapa TX dan RX disilangkan, cara membuat dua Arduino berkomunikasi satu arah lalu dua arah, batasan SoftwareSerial, cara menghubungkan board 5 V dan 3,3 V dengan aman, tiga UART ESP32, serta pin UART Raspberry Pi Pico. Pada bagian terakhir, kamu akan mempelajari cara membentuk paket dengan karakter awal dan akhir agar data tidak pernah tercampur, serta kesalahan yang paling umum.

Apa itu UART dan bagaimana cara kerjanya?

Kata “asynchronous” dalam nama UART adalah kuncinya: pada I2C dan SPI, sinyal clock dikirim bersama data, sedangkan UART tidak memiliki jalur clock. Sebagai gantinya, kedua sisi menyepakati kecepatan terlebih dahulu, yang disebut baud rate. Ketika tidak aktif, jalur berada pada HIGH (1). Untuk mengirim satu byte, pemancar menarik jalur ke LOW selama durasi satu bit; inilah bit start, yang memberi tahu penerima “mulai menghitung sekarang”. Selanjutnya dikirim 8 bit data, dengan bit paling tidak signifikan (LSB) terlebih dahulu, kemudian dapat diikuti bit paritas opsional, dan akhirnya jalur ditahan pada HIGH selama minimal durasi satu bit; inilah bit stop. Pengaturan default Arduino adalah 8N1: 8 bit data, tanpa paritas, 1 bit stop.

Setiap bit berlangsung selama 1 / baud detik. Pada 9600 baud, satu bit membutuhkan 104,2 mikrodetik; karena bingkai 8N1 terdiri dari 10 bit per byte (start + 8 data + stop), paling banyak 960 byte per detik dapat dikirim. Setelah menangkap tepi turun bit start, penerima mengambil sampel jalur di tengah setiap bit. Meskipun kedua clock sedikit berbeda, data tetap dibaca dengan benar selama galat yang terakumulasi dalam 10 bit tetap di bawah setengah bit; itulah sebabnya total galat baud harus tetap di bawah sekitar 2–3%. Dengan kristal 16 MHz-nya, Arduino Uno tidak bisa menghasilkan tepat 115200 baud, dan laju sebenarnya menyimpang sekitar 2,1%; komunikasi tetap bekerja karena masih dalam batas.

UART vs I2C vs SPI

Tiga metode komunikasi serial yang paling umum pada Arduino adalah UART, I2C, dan SPI. UART hanya bekerja satu-ke-satu antara dua perangkat, dan kedua sisi bisa berbicara kapan saja (full duplex). I2C menghubungkan puluhan perangkat pada dua kabel yang sama dengan menggunakan alamat; SPI jauh lebih cepat dengan empat kabel, tetapi membutuhkan pin pemilih terpisah untuk setiap perangkat. Untuk detailnya, lihat artikel Apa Itu I2C? dan Apa Itu SPI?.

Koneksi silang TX dan RX serta GND bersama

Aturan utama pengkabelan UART: pin TX (mengirim) satu perangkat terhubung ke pin RX (menerima) perangkat lainnya, sehingga kabelnya disilangkan. Bayangkan seperti mulut ke telinga: ketika satu sisi berbicara, sisi lainnya harus mendengarkan. Jika kamu menghubungkan TX ke TX, dua output tersambung satu sama lain dan tidak ada data yang bisa lewat. Kabel ketiga, GND, memberikan referensi tegangan yang sama kepada kedua board; tanpanya, “HIGH” dan “LOW” menjadi tidak bermakna dan data yang masuk berubah menjadi karakter sampah. Meskipun board ditenagai dari sumber terpisah, ground keduanya harus terhubung.

Membuat dua Arduino berkomunikasi: satu arah

Pada contoh pertama, board A mengirim nilai potensiometer pada A0 ke board B sepuluh kali per detik, lalu board B mengatur kecerahan LED pada D9 sesuai nilai tersebut. Kedua board menggunakan SoftwareSerial pada D10 (RX) dan D11 (TX), sehingga koneksi USB dan Serial Monitor tetap bebas digunakan. Karena nilai dikirim dengan println(), setiap angka diakhiri dengan karakter “\r\n” (akhir baris); penerima mengetahui bahwa angka sudah lengkap ketika melihatnya. Pengkabelan: D11 A ke D10 B, D10 A ke D11 B, dan kedua ground dihubungkan.

1#include <SoftwareSerial.h>
2
3SoftwareSerial link(10, 11);    // RX = 10, TX = 11 (diğer karta / to the other board)
4
5void setup() {
6  Serial.begin(9600);           // USB: bilgisayar / computer
7  link.begin(9600);             // iki tarafta aynı baud / same baud on both sides
8}
9
10void loop() {
11  int deger = analogRead(A0);   // potansiyometre 0-1023 / potentiometer 0-1023
12  link.println(deger);          // ör. "512\r\n" / e.g. "512\r\n"
13  Serial.println(deger);
14  delay(100);                   // saniyede 10 ölçüm / 10 readings per second
15}
16

1#include <SoftwareSerial.h>
2
3SoftwareSerial link(10, 11);    // RX = 10, TX = 11
4const int LED_PIN = 9;          // PWM pini / PWM pin
5
6char tampon[8];                 // en fazla 7 karakter + '\0' / up to 7 chars + '\0'
7byte konum = 0;
8
9void setup() {
10  Serial.begin(9600);
11  link.begin(9600);
12  pinMode(LED_PIN, OUTPUT);
13}
14
15void loop() {
16  while (link.available()) {               // gelen her baytı oku / read every incoming byte
17    char c = link.read();
18    if (c == '\n') {                       // satır bitti / line complete
19      tampon[konum] = '\0';
20      int deger = atoi(tampon);
21      analogWrite(LED_PIN, map(deger, 0, 1023, 0, 255));
22      Serial.println(deger);
23      konum = 0;
24    } else if (c != '\r' && konum < sizeof(tampon) - 1) {
25      tampon[konum++] = c;                 // satıra ekle / append to the line
26    }
27  }
28}
29

Ada dua hal yang perlu diperhatikan dalam kode penerima. Pertama, data tidak pernah tiba “sekaligus”: “512” tiba sebagai tiga byte terpisah, dengan jeda sekitar 1 milidetik. Karena itu, kita mengumpulkan byte dalam buffer dan mengubahnya menjadi angka ketika akhir baris tiba. Kedua, kode tidak pernah menunggu: fungsi seperti readString() atau parseInt() secara default menunggu 1 detik ketika tidak ada data yang datang dan memperlambat programmu. Membaca byte begitu tiba adalah pendekatan paling andal dan paling cepat. Kita juga membatasi ukuran buffer agar data yang rusak tidak dapat ditulis melewati batas akhir array.

Komunikasi dua arah: perintah dan balasan

Proyek nyata biasanya membutuhkan percakapan dua arah: satu board mengirim perintah, board lainnya menjalankannya dan membalas. Pada contoh berikut, board A bekerja sebagai jembatan: meneruskan setiap karakter yang kamu ketik di Serial Monitor ke B dan mencetak setiap karakter yang datang dari B. Board B memahami perintah “LED ON”, “LED OFF”, dan “DURUM?” (status), membalas masing-masing perintah, serta melaporkan secara mandiri ketika tombol pada D2 ditekan. Jangan lupa mengatur akhir baris Serial Monitor ke Newline; B menggunakan karakter tersebut untuk mengetahui bahwa perintah sudah berakhir.

1#include <SoftwareSerial.h>
2
3SoftwareSerial link(10, 11);    // RX = 10, TX = 11
4
5void setup() {
6  Serial.begin(9600);
7  link.begin(9600);
8  Serial.println("Komut yaz / type a command: LED ON, LED OFF, DURUM?");
9}
10
11void loop() {
12  if (Serial.available()) link.write(Serial.read());   // bilgisayar -> B kartı / computer -> board B
13  if (link.available()) Serial.write(link.read());     // B kartı -> bilgisayar / board B -> computer
14}
15

1#include <SoftwareSerial.h>
2
3SoftwareSerial link(10, 11);    // RX = 10, TX = 11
4const int LED_PIN = 13;         // kart üstündeki LED / on-board LED
5const int BUTON_PIN = 2;        // buton GND'ye / button to GND
6
7String satir = "";
8int oncekiButon = HIGH;
9
10void komutCalistir(String k) {
11  k.trim();                                  // \r ve boşlukları at / strip \r and spaces
12  if (k == "LED ON") {
13    digitalWrite(LED_PIN, HIGH);
14    link.println("OK LED=1");
15  } else if (k == "LED OFF") {
16    digitalWrite(LED_PIN, LOW);
17    link.println("OK LED=0");
18  } else if (k == "DURUM?") {                // durum sorgusu / status query
19    link.print("LED=");
20    link.print(digitalRead(LED_PIN));
21    link.print(" BUTON=");
22    link.println(digitalRead(BUTON_PIN) == LOW ? 1 : 0);
23  } else {
24    link.print("HATA / unknown: ");
25    link.println(k);
26  }
27}
28
29void setup() {
30  link.begin(9600);
31  pinMode(LED_PIN, OUTPUT);
32  pinMode(BUTON_PIN, INPUT_PULLUP);
33  satir.reserve(32);
34}
35
36void loop() {
37  while (link.available()) {
38    char c = link.read();
39    if (c == '\n') {
40      komutCalistir(satir);
41      satir = "";
42    } else if (satir.length() < 31) {
43      satir += c;
44    }
45  }
46
47  int buton = digitalRead(BUTON_PIN);        // değişince kendiliğinden bildir / report changes unprompted
48  if (buton != oncekiButon) {
49    oncekiButon = buton;
50    link.println(buton == LOW ? "BUTON BASILDI / pressed" : "BUTON BIRAKILDI / released");
51    delay(20);                               // basit debounce / simple debounce
52  }
53}
54

Pemanggilan trim() pada board B menghapus karakter \r yang tiba ketika Serial Monitor diatur ke “Both NL & CR”, beserta spasi berlebih, sehingga perintah dikenali dengan kedua pengaturan tersebut. Penggunaan reserve(32) untuk objek String mencegah alokasi ulang memori setiap kali karakter ditambahkan dan mengurangi fragmentasi RAM Uno yang sebesar 2 KB. Struktur ini juga menjadi dasar komunikasi dengan Arduino dari program Python di komputermu; detailnya ada dalam artikel komunikasi serial Arduino dan Python.

Batasan SoftwareSerial

SoftwareSerial meniru UART melalui perangkat lunak, bukan perangkat keras: prosesor mengatur waktu setiap bit sendiri. Ini sangat praktis, tetapi ada konsekuensinya. Selama pengiriman, interrupt dinonaktifkan sepanjang durasi setiap byte; pada 9600 baud, durasinya sekitar 1 milidetik per byte, dan selama itu millis() bisa melenceng, pulsa servo bisa mengalami jitter, serta data yang tiba pada port serial lain bisa hilang. Hanya satu port SoftwareSerial yang dapat mendengarkan pada satu waktu; jika kamu membuka port kedua, kamu harus memilih port yang mendengarkan dengan listen(). Pada board seperti Mega dan Leonardo, hanya pin tertentu dengan dukungan interrupt yang bisa digunakan sebagai RX.

Menyesuaikan level 5V dan 3.3V

Dalam UART, level “HIGH” adalah tegangan operasi board: 5 V pada Arduino Uno, 3,3 V pada ESP32, Raspberry Pi Pico, ESP-01, dan sebagian besar modul baru. Menghubungkan output TX 5 V langsung ke input RX 3,3 V membuat input terkena tegangan berlebih dan merusak pin secara bertahap atau seketika; ESP32 dan Pico berbasis RP2040 tidak tahan terhadap 5 V. Arah sebaliknya biasanya aman: Uno menganggap 3,0 V ke atas sebagai HIGH, sehingga dapat membaca TX 3,3 V, tetapi karena nilainya dekat dengan batas, level shifter lebih andal untuk kabel panjang.

UART ESP32: Serial, Serial1, dan Serial2

ESP32 memiliki tiga UART perangkat keras, dan keunggulan utamanya adalah berkat matriks GPIO, pin UART dapat dipindahkan ke hampir semua pin yang kamu inginkan. UART0 (Serial) terhubung ke chip USB-ke-serial dan digunakan untuk Serial Monitor. UART2 (Serial2) secara default berada pada GPIO 16 (RX) dan 17 (TX). Pin default lama UART1 (GPIO 9 dan 10) terhubung ke memori flash board dan tidak dapat digunakan langsung, jadi selalu mulai Serial1 dengan menentukan pin: begin(baud, SERIAL_8N1, RX, TX). Kode berikut membangun jembatan dua arah antara Serial Monitor dan perangkat pada UART2 (GPS, Arduino lain, sensor); ini ideal untuk memantau kalimat NMEA dari modul GPS.

1// ESP32: UART0 = Serial (USB), UART2 = Serial2 (GPIO 16/17)
2const int RXD2 = 16;            // karşı cihazın TX'i buraya / the other device's TX goes here
3const int TXD2 = 17;            // karşı cihazın RX'ine / to the other device's RX
4
5void setup() {
6  Serial.begin(115200);                          // USB Seri Monitör / USB Serial Monitor
7  Serial2.begin(9600, SERIAL_8N1, RXD2, TXD2);   // baud, çerçeve, RX, TX / baud, frame, RX, TX
8  // UART1'i de istediğin pinlere taşıyabilirsin / UART1 can be moved to any free pins:
9  // Serial1.begin(115200, SERIAL_8N1, 25, 26);
10  Serial.println("UART2 hazir / ready");
11}
12
13void loop() {
14  while (Serial2.available()) Serial.write(Serial2.read());   // UART2 -> USB
15  while (Serial.available()) Serial2.write(Serial.read());    // USB -> UART2
16}
17

UART ESP32 dapat mencapai 5 Mbaud dan masing-masing memiliki buffer perangkat keras; buffer penerima default sebesar 256 byte dan dapat diperbesar sebelum begin() dengan pemanggilan seperti Serial2.setRxBufferSize(1024). Ini penting untuk modul GPS yang mengirim puluhan kalimat per detik atau modul GSM dengan balasan panjang. Karena pin ESP32 bertegangan 3,3 V, jangan lupa pembagi dari bagian sebelumnya ketika menghubungkan Arduino 5 V. Kamu dapat melihat pinout ESP32 dalam alat Pinout.

Pin UART Raspberry Pi Pico dan MicroPython

Raspberry Pi Pico memiliki dua UART perangkat keras (uart0 dan uart1), dan masing-masing dapat diarahkan ke beberapa pasangan pin yang berbeda. Dalam MicroPython, REPL dan output print() dikirim melalui port serial virtual terpisah pada USB, sehingga UART0 sepenuhnya bebas digunakan; kamu tidak perlu mencabut kabel ketika meng-upload kode seperti pada Arduino. Pin Pico bertegangan 3,3 V dan pada Pico berbasis RP2040 pin-pin tersebut tidak tahan terhadap 5 V. Kode berikut menjalankan pada Pico tugas yang dilakukan board B pada Arduino: membaca baris dari UART0, menyalakan atau mematikan LED bawaan dengan perintah “LED ON” dan “LED OFF”, lalu membalas. Jika kamu ingin berkomunikasi dengan sketch jembatan Uno, jangan lupa memasang pembagi tegangan pada jalur TX Uno.

1from machine import UART, Pin
2import time
3
4uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1))   # UART0: GP0 = TX, GP1 = RX
5led = Pin("LED", Pin.OUT)                             # Pico ve Pico W dahili LED / on-board LED
6
7tampon = b""
8while True:
9    if uart.any():
10        tampon += uart.read()                         # gelen baytlar / incoming bytes
11        while b"\n" in tampon:                        # her tam satırı işle / handle each full line
12            satir, tampon = tampon.split(b"\n", 1)
13            try:
14                komut = satir.decode().strip()
15            except UnicodeError:
16                continue                              # bozuk bayt: atla / corrupt byte: skip
17            if komut == "LED ON":
18                led.on()
19                uart.write("OK LED=1\n")
20            elif komut == "LED OFF":
21                led.off()
22                uart.write("OK LED=0\n")
23            else:
24                uart.write("HATA / unknown: " + komut + "\n")
25    if len(tampon) > 64:                              # satır sonu hiç gelmezse taşmayı önle / avoid overflow
26        tampon = b""
27    time.sleep_ms(5)
28

Pembingkaian paket: karakter awal dan akhir

UART adalah aliran byte; UART tidak mengetahui di mana sesuatu dimulai atau berakhir. Ketika pengirim menulis “23.5,48,812”, penerima mungkin baru mulai mendengarkan di tengah pengiriman, sebuah byte mungkin hilang akibat derau, atau dua pembacaan mungkin menyatu. Solusinya adalah mengubah data menjadi paket: jika setiap paket dimulai dengan “<” dan diakhiri dengan “>”, penerima mengabaikan semuanya hingga “<” pertama, memproses paket ketika “>” tiba, dan membuang paket tidak lengkap yang muncul di antaranya. Pengirim hanya perlu mencetak nilai di antara Serial.print('<'), tanda koma, dan Serial.print('>'). Kamu bisa langsung mencoba kode penerima berikut dengan mengetik <23.5,48,812> di Serial Monitor.

1// Paket biçimi / packet format: <sicaklik,nem,isik>  ör. / e.g. <23.5,48,812>
2const byte MAKS = 32;
3char tampon[MAKS];
4byte konum = 0;
5bool paketIcinde = false;                    // '<' görüldü mü? / have we seen '<'?
6
7void paketiIsle(char* p) {
8  char* parca = strtok(p, ",");              // ilk alan / first field
9  if (!parca) return;
10  float sicaklik = atof(parca);
11  parca = strtok(NULL, ",");
12  if (!parca) return;                        // eksik alan: paketi at / missing field: drop
13  int nem = atoi(parca);
14  parca = strtok(NULL, ",");
15  if (!parca) return;
16  int isik = atoi(parca);
17
18  Serial.print("Sicaklik / temp: ");
19  Serial.print(sicaklik, 1);
20  Serial.print("  Nem / humidity: ");
21  Serial.print(nem);
22  Serial.print("  Isik / light: ");
23  Serial.println(isik);
24}
25
26void setup() {
27  Serial.begin(9600);                        // Seri Monitör'den <23.5,48,812> yazarak dene / test from the Serial Monitor
28}
29
30void loop() {
31  while (Serial.available()) {
32    char c = Serial.read();
33    if (c == '<') {                          // yeni paket başladı / a new packet starts
34      paketIcinde = true;
35      konum = 0;
36    } else if (c == '>' && paketIcinde) {    // paket bitti / packet complete
37      tampon[konum] = '\0';
38      paketIcinde = false;
39      paketiIsle(tampon);
40    } else if (paketIcinde) {
41      if (konum < MAKS - 1) tampon[konum++] = c;
42      else paketIcinde = false;              // çok uzun, bozuk: at / too long, corrupt: drop
43    }                                        // paket dışındaki baytlar yok sayılır / bytes outside packets are ignored
44  }
45}
46

Di lingkungan berderau atau dengan kabel panjang, kamu bisa melangkah lebih jauh dan menambahkan checksum ke paket. Format NMEA yang digunakan modul GPS adalah contoh yang bagus: semua karakter antara “$” dan “*” di-XOR bersama, lalu hasilnya ditulis di bagian akhir sebagai angka heksadesimal dua digit. Penerima melakukan perhitungan yang sama dan membuang paket jika hasilnya tidak cocok. Ini melindungimu dari galat tersembunyi, seperti “812” yang rusak lalu diproses sebagai “872”.

Ide proyek UART

• Kendali dari ponsel: modul Bluetooth HC-05 sebenarnya adalah UART nirkabel; kendalikan LED, relay, atau mobil robot dari ponselmu dengan HC-05.
• Pencatatan GPS: uraikan kalimat NMEA yang dikirim modul NEO-6M GPS melalui UART dan tulis posisinya ke kartu SD.
• Sistem dua board: hubungkan Uno yang membaca sensor ke ESP32 yang mengirim data ke internet melalui Wi-Fi, menggunakan UART.
• Alarm SMS: kirim perintah AT ke modul SIM800L melalui UART dan kirim SMS ke dirimu ketika pintu terbuka.
• Panel kendali komputer: kirim perintah ke Arduino dari aplikasi desktop yang ditulis dalam Python dan tampilkan data sensor dalam grafik.
• Pemutar MP3: pilih lagu, atur volume, dan putar peringatan suara melalui UART dengan DFPlayer Mini.

Kesalahan umum dan solusinya

UART adalah metode komunikasi pertama yang perlu dipelajari dalam elektronika: cukup dua kabel, GND bersama, dan baud rate yang sama, dan jika dipasang dengan benar, komunikasi ini dapat bekerja bertahun-tahun tanpa masalah. Setelah menguasai pengkabelan silang, penyesuaian level, dan pembingkaian paket, kamu bisa menggunakan puluhan modul dari GPS hingga GSM dengan mudah. Dalam aplikasi BlueGrays, kamu akan menemukan proyek langkah demi langkah dengan skema rangkaian dan kode untuk komunikasi satu arah dan dua arah antara dua Arduino, menyalakan LED dari ponsel melalui Bluetooth, serta mobil yang dikendalikan melalui Bluetooth.