.: Komunikasi Antar ESP32 / ESP8266 Menggunakan WIFI dan IP LOCAL

Komunikasi Antar ESP32 / ESP8266 Menggunakan WIFI dan IP LOCAL

Pada kesempatan kali ini saya akan menjelaskan mengenai bagaimana cara membuat sebuah alat yang menggunakan komunikasi wifi, jadi terdapat 2 board ESP32 yang mengirimkan data suhu kepada board ESP32 Receiver, kemudian dari board ESP32 receiver data di tampilkan ke web browser dengan menggunakan IP Local. untuk lebih jelasnya berikut adalah koding dan skemanya.

1. ESP32 Transmitter

2. ESP32 Receiver

3. Setelah dipasang sensor DS18b20 ke ESP32 kemudian lakukan pembacaan MAC ADDRESS ESP32 Receiver dahulu dengan menggunakan koding berikut, maka akan tampil di serial monitor seperti gambar dibawah, jangan lupa tekan dulu tombol EN di board ESP32

#ifdef ESP32

#include <WiFi.h>

#else

#include <ESP8266WiFi.h>

#endif

void setup(){

Serial.begin(115200);

Serial.println();

Serial.print("ESP Board MAC Address: ");

Serial.println(WiFi.macAddress());

}

void loop(){

}

4. Setelah dapat MAC Address Receiver ESP32 kemudian upload koding transmitter berikut ke Board ESP32 sebagai Transmitter dan ubah MAC Address sesuai dengan MAC Address Receiver

#include <esp_now.h>

#include <esp_wifi.h>

#include <WiFi.h>

#include <Wire.h>

#include <DallasTemperature.h>

#include <OneWire.h>

#include <SPI.h>

#define ONE_WIRE_BUS 17 //D3 pin of nodemcu

// Set your Board ID (ESP32 Sender #1 = BOARD_ID 1, ESP32 Sender #2 = BOARD_ID 2, etc)

#define BOARD_ID 1

// Digital pin connected to the DHT sensor

OneWire oneWire(ONE_WIRE_BUS);

DallasTemperature sensors(&oneWire);

float t;

//MAC Address of the receiver

uint8_t broadcastAddress[] = {0x94, 0x3C, 0xC6, 0x33, 0x81, 0xD0};

//Structure example to send data

//Must match the receiver structure

typedef struct struct_message {

int id;

float temp;

int readingId;

} struct_message;

//Create a struct_message called myData

struct_message myData;

unsigned long previousMillis = 0; // Stores last time temperature was published

const long interval = 10000; // Interval at which to publish sensor readings

unsigned int readingId = 0;

// Insert your SSID

constexpr char WIFI_SSID[] = "Mipad";

int32_t getWiFiChannel(const char *ssid) {

if (int32_t n = WiFi.scanNetworks()) {

for (uint8_t i=0; i<n; i++) {

if (!strcmp(ssid, WiFi.SSID(i).c_str())) {

return WiFi.channel(i);

}

return 0;

}

float readDSTemperature() {

sensors.requestTemperatures();

t = sensors.getTempCByIndex(0);

if (isnan(t)) {

Serial.println("Failed to read from DS sensor!");

return 0;

}

else {

Serial.println(t);

return t;

}

// 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);

sensors.begin();

// Set device as a Wi-Fi Station and set channel

WiFi.mode(WIFI_STA);

int32_t channel = getWiFiChannel(WIFI_SSID);

WiFi.printDiag(Serial); // Uncomment to verify channel number before

esp_wifi_set_promiscuous(true);

esp_wifi_set_channel(channel, WIFI_SECOND_CHAN_NONE);

esp_wifi_set_promiscuous(false);

WiFi.printDiag(Serial); // Uncomment to verify channel change after

//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(OnDataSent);

//Register peer

esp_now_peer_info_t peerInfo;

memcpy(peerInfo.peer_addr, broadcastAddress, 6);

peerInfo.encrypt = false;

//Add peer

if (esp_now_add_peer(&peerInfo) != ESP_OK){

Serial.println("Failed to add peer");

return;

}

void loop() {

unsigned long currentMillis = millis();

if (currentMillis - previousMillis >= interval) {

// Save the last time a new reading was published

previousMillis = currentMillis;

//Set values to send

myData.id = BOARD_ID;

myData.temp = readDSTemperature();

myData.readingId = readingId++;

//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");

}

5. Kemudian Upload koding ESP32 Receiver berikut.

#include <esp_now.h>

#include <WiFi.h>

#include "ESPAsyncWebServer.h"

#include <Arduino_JSON.h>

// Replace with your network credentials (STATION)

const char* ssid = "Mipad";

const char* password = "123456789";

// Structure example to receive data

// Must match the sender structure

typedef struct struct_message {

int id;

float temp;

float hum;

unsigned int readingId;

} struct_message;

struct_message incomingReadings;

JSONVar board;

AsyncWebServer server(80);

AsyncEventSource events("/events");

// callback function that will be executed when data is received

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

// Copies the sender mac address to a string

char macStr[18];

Serial.print("Packet received from: ");

snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",

mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);

Serial.println(macStr);

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

board["id"] = incomingReadings.id;

board["temperature"] = incomingReadings.temp;

board["humidity"] = incomingReadings.hum;

board["readingId"] = String(incomingReadings.readingId);

String jsonString = JSON.stringify(board);

events.send(jsonString.c_str(), "new_readings", millis());

Serial.printf("Board ID %u: %u bytes\n", incomingReadings.id, len);

Serial.printf("t value: %4.2f \n", incomingReadings.temp);

Serial.printf("h value: %4.2f \n", incomingReadings.hum);

Serial.printf("readingID value: %d \n", incomingReadings.readingId);

Serial.println();

}

const char index_html[] PROGMEM = R"rawliteral(

<!DOCTYPE HTML><html>

<head>

<title>ESP-NOW DASHBOARD</title>

<style>

html {font-family: Arial; display: inline-block; text-align: center;}

p { font-size: 1.2rem;}

body { margin: 0;}

.topnav { overflow: hidden; background-color: #2f4468; color: white; font-size: 1.7rem; }

.content { padding: 20px; }

.card { background-color: white; box-shadow: 2px 2px 12px 1px rgba(140,140,140,.5); }

.cards { max-width: 700px; margin: 0 auto; display: grid; grid-gap: 2rem; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); }

.reading { font-size: 2.8rem; }

.packet { color: #bebebe; }

.card.temperature { color: #fd7e14; }

.card.humidity { color: #1b78e2; }

</style>

</head>

<body>

<h3>MONITOR SUHU</h3>

</div>

<h4><i class="fas fa-thermometer-half"></i> BOARD #1 - TEMPERATURE</h4><p><span class="reading"><span id="t1"></span> °C</span></p><p class="packet">Reading ID: <span id="rt1"></span></p>

</div>

<h4><i class="fas fa-thermometer-half"></i> BOARD #2 - TEMPERATURE</h4><p><span class="reading"><span id="t2"></span> °C</span></p><p class="packet">Reading ID: <span id="rt2"></span></p>

</div>

if (!!window.EventSource) {

var source = new EventSource('/events');

source.addEventListener('open', function(e) {

console.log("Events Connected");

}, false);

source.addEventListener('error', function(e) {

if (e.target.readyState != EventSource.OPEN) {

console.log("Events Disconnected");

}

}, false);

source.addEventListener('message', function(e) {

console.log("message", e.data);

}, false);

source.addEventListener('new_readings', function(e) {

console.log("new_readings", e.data);

var obj = JSON.parse(e.data);

document.getElementById("t"+obj.id).innerHTML = obj.temperature.toFixed(2);

document.getElementById("h"+obj.id).innerHTML = obj.humidity.toFixed(2);

document.getElementById("rt"+obj.id).innerHTML = obj.readingId;

document.getElementById("rh"+obj.id).innerHTML = obj.readingId;

}, false);

}

</script>

</body>

</html>)rawliteral";

void setup() {

// Initialize Serial Monitor

Serial.begin(115200);

// Set the device as a Station and Soft Access Point simultaneously

WiFi.mode(WIFI_AP_STA);

// Set device as a Wi-Fi Station

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {

delay(1000);

Serial.println("Setting as a Wi-Fi Station..");

}

Serial.print("Station IP Address: ");

Serial.println(WiFi.localIP());

Serial.print("Wi-Fi Channel: ");

Serial.println(WiFi.channel());

// 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(OnDataRecv);

server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){

request->send_P(200, "text/html", index_html);

});

events.onConnect([](AsyncEventSourceClient *client){

if(client->lastId()){

Serial.printf("Client reconnected! Last message ID that it got is: %u\n", client->lastId());

}

// send event with message "hello!", id current millis

// and set reconnect delay to 1 second

client->send("hello!", NULL, millis(), 10000);

});

server.addHandler(&events);

server.begin();

}

void loop() {

static unsigned long lastEventTime = millis();

static const unsigned long EVENT_INTERVAL_MS = 5000;

if ((millis() - lastEventTime) > EVENT_INTERVAL_MS) {

events.send("ping",NULL,millis());

lastEventTime = millis();

}

6. Setelah itu buka serial monitor lalu tekan EN pada board ESP32 Receiver maka akan tampil IP Address, kemudian ketikkan IP tersebut pada web browser maka tampilannya akan seperti beriku ini.