ESP32, Electronics, TUTORIAL

Tutorial ESP-NOW ESP32: Broadcast Data ke Banyak ESP32 Tanpa WiFi

Posted by author-avatar
0

Memulai dengan ESP-NOW (ESP32 menggunakan Arduino IDE)

Pelajari cara menggunakan ESP-NOW untuk bertukar data antar papan ESP32 yang diprogram menggunakan Arduino IDE. ESP-NOW adalah protokol komunikasi tanpa koneksi yang dikembangkan oleh Espressif dan memiliki fitur pengiriman paket berukuran pendek. Protokol ini memungkinkan beberapa perangkat untuk saling berkomunikasi dengan cara yang mudah.

Arduino IDE

Kita akan memprogram papan ESP32 menggunakan Arduino IDE, jadi sebelum melanjutkan tutorial ini kamu harus sudah menginstal add-on ESP32 pada Arduino IDE.

Mengutip dari situs web Espressif, ESP-NOW adalah “sebuah protokol yang dikembangkan oleh Espressif, yang memungkinkan beberapa perangkat untuk saling berkomunikasi tanpa menggunakan Wi-Fi. Protokol ini mirip dengan konektivitas nirkabel 2,4 GHz berdaya rendah (…). Proses pairing antar perangkat diperlukan sebelum komunikasi dilakukan. Setelah pairing selesai, koneksi bersifat aman dan peer-to-peer, tanpa memerlukan handshake.”

Artinya, setelah perangkat dipasangkan satu sama lain, koneksinya bersifat persisten. Dengan kata lain, jika tiba-tiba salah satu papan kehilangan daya atau melakukan reset, saat papan tersebut menyala kembali, ia akan secara otomatis terhubung ke peer-nya untuk melanjutkan komunikasi.

ESP-NOW mendukung fitur-fitur berikut:

Komunikasi unicast terenkripsi dan tidak terenkripsi;
Perangkat peer dengan enkripsi dan tanpa enkripsi secara campuran;
Payload hingga 250 byte dapat dikirim;
Fungsi callback pengiriman yang dapat diatur untuk memberi tahu lapisan aplikasi apakah transmisi berhasil atau gagal.

Teknologi ESP-NOW juga memiliki keterbatasan sebagai berikut:

Jumlah peer terenkripsi terbatas. Maksimal 10 peer terenkripsi didukung dalam mode Station; maksimal 6 dalam mode SoftAP atau SoftAP + Station;
Beberapa peer tanpa enkripsi didukung, namun jumlah totalnya harus kurang dari 20, termasuk peer terenkripsi;
Payload dibatasi hingga 250 byte.

Secara sederhana, ESP-NOW adalah protokol komunikasi cepat yang dapat digunakan untuk bertukar pesan berukuran kecil (hingga 250 byte) antar papan ESP32.

ESP-NOW sangat fleksibel dan memungkinkan komunikasi satu arah maupun dua arah dalam berbagai konfigurasi.

Komunikasi Satu Arah ESP-NOW

Sebagai contoh, pada komunikasi satu arah, kamu bisa memiliki skenario seperti berikut:

Satu papan ESP32 mengirimkan data ke papan ESP32 lainnya.

Konfigurasi ini sangat mudah untuk diimplementasikan dan sangat cocok untuk mengirim data dari satu papan ke papan lainnya, seperti data pembacaan sensor atau perintah ON dan OFF untuk mengontrol GPIO.

Satu papan ESP32 mengirimkan perintah yang sama atau berbeda ke beberapa papan ESP32 lainnya. Konfigurasi ini ideal untuk membuat sesuatu seperti remote control. Kamu dapat memiliki beberapa papan ESP32 di sekitar rumah yang dikendalikan oleh satu papan ESP32 utama.

Konfigurasi ini juga ideal jika kamu ingin mengumpulkan data dari beberapa node sensor ke satu papan ESP32. Papan tersebut dapat dikonfigurasikan sebagai web server untuk menampilkan data dari semua papan lainnya, sebagai contoh.

Catatan: dalam dokumentasi ESP-NOW tidak ada istilah seperti “sender/master” dan “receiver/slave”. Setiap papan dapat berperan sebagai pengirim maupun penerima. Namun, untuk menjaga kejelasan, kita akan menggunakan istilah “sender” dan “receiver” atau “master” dan “slave”.

Komunikasi Dua Arah ESP-NOW

Dengan ESP-NOW, setiap papan dapat menjadi pengirim dan penerima secara bersamaan. Dengan demikian, kamu dapat membangun komunikasi dua arah antar papan.

Sebagai contoh, kamu dapat memiliki dua papan yang saling berkomunikasi satu sama lain.

Kamu dapat menambahkan lebih banyak papan ke dalam konfigurasi ini dan membuat sesuatu yang menyerupai sebuah jaringan (semua papan ESP32 saling berkomunikasi satu sama lain).

Singkatnya, ESP-NOW sangat ideal untuk membangun sebuah jaringan di mana kamu dapat memiliki beberapa papan ESP32 yang saling bertukar data satu sama lain.

ESP32: Mendapatkan Alamat MAC Board

Untuk berkomunikasi melalui ESP-NOW, kamu perlu mengetahui alamat MAC dari ESP32 penerima. Dengan begitu, kamu tahu ke perangkat mana data akan dikirim.Setiap ESP32 memiliki alamat MAC yang unik dan itulah cara kita mengidentifikasi setiap papan untuk mengirim data kepadanya menggunakan ESP-NOW (pelajari cara Mendapatkan dan Mengubah Alamat MAC ESP32).

Untuk mendapatkan alamat MAC board kamu, unggah kode berikut.

/*
  Rui Santos & Sara Santos - Random Nerd Tutorials
  Complete project details at https://RandomNerdTutorials.com/get-change-esp32-esp8266-mac-address-arduino/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.  
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/
#include <WiFi.h>
#include <esp_wifi.h>

void readMacAddress(){
  uint8_t baseMac[6];
  esp_err_t ret = esp_wifi_get_mac(WIFI_IF_STA, baseMac);
  if (ret == ESP_OK) {
    Serial.printf("%02x:%02x:%02x:%02x:%02x:%02x\n",
                  baseMac[0], baseMac[1], baseMac[2],
                  baseMac[3], baseMac[4], baseMac[5]);
  } else {
    Serial.println("Failed to read MAC address");
  }
}

void setup(){
  Serial.begin(115200);

  WiFi.mode(WIFI_STA);
  WiFi.STA.begin();

  Serial.print("[DEFAULT] ESP32 Board MAC Address: ");
  readMacAddress();
}
 
void loop(){

}

Setelah kamu selesai upload program ke ESP32, kamu harus membuka Serial Monitor di Arduino IDE.
Di Serial Monitor itu, set baud rate ke 115200. Setelah Serial Monitor terbuka, tekan tombol RST atau EN di board ESP32.
Kalau semua benar dan kodenya jalan, alamat MAC ESP32 akan muncul di Serial Monitor dalam format tertentu.

Simpan alamat MAC board  kamu karena alamat tersebut akan diperlukan untuk mengirim data ke papan yang tepat melalui ESP-NOW.

Komunikasi Satu Arah Point to Point ESP-NOW
Untuk memulai komunikasi nirkabel ESP-NOW, kita akan membuat proyek sederhana yang menunjukkan cara mengirim pesan dari satu ESP32 ke ESP32 lainnya. Satu ESP32 akan berperan sebagai “sender” dan ESP32 lainnya sebagai “receiver”.

Kita akan mengirim sebuah struktur yang berisi variabel bertipe char, int, float, dan boolean. Selanjutnya, kamu dapat memodifikasi struktur tersebut untuk mengirim tipe variabel apa pun yang sesuai dengan proyekmu (seperti data pembacaan sensor, atau variabel boolean untuk menyalakan atau mematikan sesuatu).

Untuk memudahkan pemahaman, kita akan menyebut ESP32 #1 sebagai “sender” dan ESP32 #2 sebagai “receiver”.

Berikut hal-hal yang perlu disertakan pada sketch sender:

  • Menginisialisasi ESP-NOW;
  • Mendaftarkan fungsi callback saat pengiriman data – fungsi OnDataSent akan dijalankan ketika sebuah pesan dikirim. Fungsi ini dapat memberi tahu apakah pesan berhasil dikirim atau tidak;
  • Menambahkan perangkat peer (receiver). Untuk ini, kamu perlu mengetahui alamat MAC receiver;
  • Mengirim pesan ke perangkat peer.

Pada sisi receiver, sketch harus mencakup:

  • Menginisialisasi ESP-NOW;
  • Mendaftarkan fungsi callback penerimaan (OnDataRecv). Ini adalah fungsi yang akan dijalankan ketika sebuah pesan diterima.
  • Di dalam fungsi callback tersebut, menyimpan pesan ke dalam sebuah variabel untuk menjalankan tugas apa pun berdasarkan informasi tersebut.

ESP-NOW bekerja menggunakan fungsi callback yang dipanggil ketika sebuah perangkat menerima pesan atau ketika sebuah pesan dikirim (kamu akan mengetahui apakah pesan berhasil dikirim atau gagal).

Fungsi-Fungsi Berguna ESP-NOW
 Berikut ringkasan fungsi ESP-NOW yang paling penting:

Nama Fungsi dan Deskripsi

  • esp_now_init() – Menginisialisasi ESP-NOW. Kamu harus menginisialisasi Wi-Fi sebelum menginisialisasi ESP-NOW.
    esp_now_add_peer() Panggil fungsi ini untuk melakukan pairing dengan sebuah perangkat dan berikan sebagai argumen alamat MAC peer.
  • esp_now_send() – Mengirim data dengan ESP-NOW.
  • esp_now_register_send_cb() – Mendaftarkan fungsi callback yang dipicu saat pengiriman data. Ketika sebuah pesan dikirim, sebuah fungsi akan dipanggil – fungsi ini mengembalikan apakah pengiriman berhasil atau tidak.
  • esp_now_register_recv_cb() – Mendaftarkan fungsi callback yang dipicu saat penerimaan data. Ketika data diterima melalui ESP-NOW, sebuah fungsi akan dipanggil.

Sketch ESP32 Pengirim (ESP-NOW)

Berikut adalah kode untuk papan ESP32 pengirim. Salin kode tersebut ke Arduino IDE kamu, tetapi jangan unggah dulu. Kamu perlu melakukan beberapa modifikasi agar kode itu dapat berfungsi untuk kamu.

Atau kami bisa akses codingannya di sini.

/*
  CNC STORE BANDUNG
*/
#include <esp_now.h>
#include <WiFi.h>

// REPLACE WITH YOUR RECEIVER MAC Address
uint8_t broadcastAddress[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

// Structure example to send data
// Must match the receiver structure
typedef struct struct_message {
  char a[32];
  int b;
  float c;
  bool d;
} struct_message;

// Create a struct_message called myData
struct_message myData;

esp_now_peer_info_t peerInfo;

// callback when data is sent
void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
  Serial.print("\r\nLast Packet Send Status:\t");
  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
}
 
void setup() {
  // Init Serial Monitor
  Serial.begin(115200);
 
  // Set device as a Wi-Fi Station
  WiFi.mode(WIFI_STA);

  // Init ESP-NOW
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }

  // Once ESPNow is successfully Init, we will register for Send CB to
  // get the status of Trasnmitted packet
  esp_now_register_send_cb(esp_now_send_cb_t(OnDataSent));
  
  // Register peer
  memcpy(peerInfo.peer_addr, broadcastAddress, 6);
  peerInfo.channel = 0;  
  peerInfo.encrypt = false;
  
  // Add peer        
  if (esp_now_add_peer(&peerInfo) != ESP_OK){
    Serial.println("Failed to add peer");
    return;
  }
}
 
void loop() {
  // Set values to send
  strcpy(myData.a, "THIS IS A CHAR");
  myData.b = random(1,20);
  myData.c = 1.2;
  myData.d = false;
  
  // Send message via ESP-NOW
  esp_err_t result = esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData));
   
  if (result == ESP_OK) {
    Serial.println("Sent with success");
  }
  else {
    Serial.println("Error sending the data");
  }
  delay(2000);
}

Cara kerja kode
Pertama, sertakan library esp_now.h dan WiFi.h.

#include <esp_now.h>
#include <WiFi.h>

Pada baris berikutnya, kamu harus memasukkan alamat MAC ESP32 penerima.

uint8_t broadcastAddress[] = {0x30, 0xAE, 0xA4, 0x07, 0x0D, 0x64};

Dalam kasus kami, alamat MAC receiver adalah: 30:AE:A4:07:0D:64, tetapi kamu perlu mengganti variabel tersebut dengan alamat MAC milikmu sendiri.Kemudian, buat sebuah struktur yang berisi tipe data yang ingin kita kirim. Struktur ini kami beri nama struct_message dan berisi 4 tipe variabel yang berbeda. Kamu dapat mengubahnya untuk mengirim tipe variabel lain sesuai kebutuhan.

typedef struct struct_message {
  char a[32];
  int b;
  float c;
  bool d;
} struct_message;

Kemudian, buat sebuah variabel baru bertipe struct_message yang diberi nama myData, yang akan menyimpan nilai dari variabel-variabel tersebut.

struct_message myData;

Buat sebuah variabel bertipe esp_now_peer_info_t untuk menyimpan informasi tentang perangkat peer.

esp_now_peer_info_t peerInfo;

Selanjutnya, definisikan fungsi OnDataSent(). Ini adalah fungsi callback yang akan dijalankan ketika sebuah pesan dikirim. Dalam hal ini, fungsi tersebut hanya menampilkan apakah pesan berhasil dikirim atau tidak.

void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
  Serial.print("\r\nLast Packet Send Status:\t");
  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
}

Pada setup(), inisialisasikan Serial Monitor untuk keperluan debugging:

Serial.begin(115200);

Atur perangkat sebagai Wi-Fi station:

WiFi.mode(WIFI_STA);

Inisialisasi ESP-NOW:

if (esp_now_init() != ESP_OK) {
  Serial.println("Error initializing ESP-NOW");
  return;
}

Setelah ESP-NOW berhasil diinisialisasi, daftarkan fungsi callback yang akan dipanggil ketika sebuah pesan dikirim. Dalam hal ini, kita mendaftarkan fungsi OnDataSent() yang dibuat sebelumnya.

esp_now_register_send_cb(OnDataSent);

Setelah itu, kita perlu melakukan pairing dengan perangkat ESP-NOW lain untuk mengirim data. Itulah yang kita lakukan pada baris-baris berikutnya:

//Register peer
memcpy(peerInfo.peer_addr, broadcastAddress, 6);
peerInfo.channel = 0;
peerInfo.encrypt = false;

//Add peer
if (esp_now_add_peer(&peerInfo) != ESP_OK){
  Serial.println("Failed to add peer");
  return;
}

Pada loop(), kita akan mengirim sebuah pesan melalui ESP-NOW setiap 2 detik (kamu dapat mengubah waktu jeda ini).

Pertama, kita mengatur nilai variabel sebagai berikut:

strcpy(myData.a, "THIS IS A CHAR");
myData.b = random(1,20);
myData.c = 1.2;
myData.d = false;

Ingat bahwa myData adalah sebuah struktur. Di sini kita menetapkan nilai-nilai yang ingin dikirim ke dalam struktur tersebut. Sebagai contoh, baris pertama menetapkan sebuah char, baris kedua menetapkan sebuah angka Int acak, sebuah Float, dan sebuah variabel Boolean.

Struktur seperti ini dibuat untuk menunjukkan cara mengirim tipe variabel yang paling umum. Kamu dapat mengubah struktur tersebut untuk mengirim tipe data lain.

Terakhir, kirim pesan sebagai berikut:

esp_err_t result = esp_now_send(broadcastAddress, (uint8_t *) &myData, sizeof(myData));

Periksa apakah pesan berhasil dikirim:

if (result == ESP_OK) {
  Serial.println("Sent with success");
}
else {
  Serial.println("Error sending the data");
}

Fungsi loop() dijalankan setiap 2000 milidetik (2 detik).

delay(2000);

Sketch ESP32 Penerima (ESP-NOW)

Unggah kode berikut ke papan ESP32 penerima kamu.

/*
 CNC STORE BANDUNG
*/

#include <esp_now.h>
#include <WiFi.h>

// Structure example to receive data
// Must match the sender structure
typedef struct struct_message {
    char a[32];
    int b;
    float c;
    bool d;
} struct_message;

// Create a struct_message called myData
struct_message myData;

// callback function that will be executed when data is received
void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) {
  memcpy(&myData, incomingData, sizeof(myData));
  Serial.print("Bytes received: ");
  Serial.println(len);
  Serial.print("Char: ");
  Serial.println(myData.a);
  Serial.print("Int: ");
  Serial.println(myData.b);
  Serial.print("Float: ");
  Serial.println(myData.c);
  Serial.print("Bool: ");
  Serial.println(myData.d);
  Serial.println();
}
 
void setup() {
  // Initialize Serial Monitor
  Serial.begin(115200);
  
  // Set device as a Wi-Fi Station
  WiFi.mode(WIFI_STA);

  // Init ESP-NOW
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }
  
  // Once ESPNow is successfully Init, we will register for recv CB to
  // get recv packer info
  esp_now_register_recv_cb(esp_now_recv_cb_t(OnDataRecv));
}
 
void loop() {

}

Cara kerja kode
Mirip seperti pada pengirim, mulailah dengan menyertakan library:

#include <esp_now.h>
#include <WiFi.h>

Buat sebuah struktur untuk menerima data. Struktur ini harus sama seperti yang didefinisikan pada sketch pengirim.

typedef struct struct_message {
  char a[32];
  int b;
  float c;
  bool d;
} struct_message;

Buat sebuah variabel bertipe struct_message bernama myData.

struct_message myData;

Create a callback function that will be called when the ESP32 receives the data via ESP-NOW. The function is called onDataRecv() and should accept several parameters as follows:

void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) {

We copy the content of the incomingData data variable into the myData variable.

memcpy(&myData, incomingData, sizeof(myData));

Now, the myData structure contains several variables inside with the values sent by the ESP32 sender. To access variable a, for example, we just need to call myData.a.

In this example, we simply print the received data, but in a practical application you can print the data on a display, for example.

Serial.print("Bytes received: ");
Serial.println(len);
Serial.print("Char: ");
Serial.println(myData.a);
Serial.print("Int: ");
Serial.println(myData.b);
Serial.print("Float: ");
Serial.println(myData.c);
Serial.print("Bool: ");
Serial.println(myData.d);
Serial.println();

In the setup(), intialize the Serial Monitor.

Serial.begin(115200);

Pada setup(), lakukan inisialisasi Serial Monitor.

Atur perangkat sebagai Wi-Fi Station.

WiFi.mode(WIFI_STA);

Initialize ESP-NOW:

if (esp_now_init() != ESP_OK) {
  Serial.println("Error initializing ESP-NOW");
  return;
}

Daftarkan sebuah fungsi callback yang akan dipanggil ketika data diterima. Dalam hal ini, kita mendaftarkan fungsi OnDataRecv() yang telah dibuat sebelumnya.

esp_now_register_recv_cb(esp_now_recv_cb_t(OnDataRecv));

Pengujian Komunikasi ESP-NOW

Unggah sketch pengirim ke papan ESP32 pengirim dan sketch penerima ke papan ESP32 penerima.

Sekarang, buka dua jendela Arduino IDE. Satu untuk penerima, dan satu lagi untuk pengirim. Buka Serial Monitor untuk masing-masing papan. Setiap papan harus menggunakan port COM yang berbeda.

Berikut adalah tampilan yang seharusnya kamu dapatkan di sisi pengirim.

Dan berikut adalah tampilan yang seharusnya kamu dapatkan di sisi penerima. Perhatikan bahwa variabel Int berubah pada setiap pembacaan yang diterima (karena pada sisi pengirim kita mengaturnya sebagai angka acak).

Kami menguji jangkauan komunikasi antara dua papan tersebut, dan kami berhasil mendapatkan komunikasi yang stabil hingga 220 meter (sekitar 722 kaki) di area terbuka. Dalam percobaan ini, kedua antena onboard ESP32 saling diarahkan satu sama lain.

Penutup
Kami berusaha menjaga contoh-contoh kami sesederhana mungkin agar kamu dapat lebih memahami bagaimana semuanya bekerja. Ada lebih banyak fungsi terkait ESP-NOW yang dapat berguna dalam proyek-proyekmu, seperti: mengelola peer, menghapus peer, memindai perangkat slave, dan lain-lain. Untuk contoh yang lebih lengkap, di Arduino IDE kamu dapat masuk ke File > Examples > ESP32 > ESPNow dan memilih salah satu sketch contoh.

Kami harap kamu merasa pengenalan ESP-NOW ini bermanfaat. Sebagai contoh awal yang sederhana, kami telah menunjukkan cara mengirim data dalam bentuk struktur dari satu ESP32 ke ESP32 lainnya. Ide utamanya adalah mengganti nilai-nilai struktur tersebut dengan data pembacaan sensor atau status GPIO, sebagai contoh.

Selain itu, dengan ESP-NOW, setiap papan dapat secara bersamaan berperan sebagai pengirim dan penerima. Satu papan dapat mengirim data ke beberapa papan sekaligus dan juga menerima data dari beberapa papan.

Kami juga memiliki tutorial tentang ESP-NOW dengan ESP8266: Memulai dengan ESP-NOW (ESP8266 NodeMCU menggunakan Arduino IDE).

Untuk mempelajari lebih lanjut tentang papan ESP32, pastikan kamu melihat sumber daya kami:

Translated from https://randomnerdtutorials.com/

Produk yang direkomendasikan

Back to list
Older Panduan Lengkap Menggunakan Sensor Suhu DS18B20 dengan Arduino

Related Posts

    Tinggalkan Balasan