Wikifab - Contributions de l’utilisateur [fr]

Getting Started with ESP-NOW

2024-06-02T13:53:41Z

Simijames :

{{Tuto Details
|Main_Picture=Getting_Started_with_ESP-NOW_1.PNG
|Main_Picture_annotation={"version":"2.4.6","objects":[{"type":"image","version":"2.4.6","originX":"left","originY":"top","left":-2,"top":-4,"width":763,"height":572,"fill":"rgb(0,0,0)","stroke":null,"strokeWidth":0,"strokeDashArray":null,"strokeLineCap":"butt","strokeDashOffset":0,"strokeLineJoin":"miter","strokeMiterLimit":4,"scaleX":0.79,"scaleY":0.79,"angle":0,"flipX":false,"flipY":false,"opacity":1,"shadow":null,"visible":true,"clipTo":null,"backgroundColor":"","fillRule":"nonzero","paintFirst":"fill","globalCompositeOperation":"source-over","transformMatrix":null,"skewX":0,"skewY":0,"crossOrigin":"","cropX":0,"cropY":0,"src":"https://wikifab.org/images/8/8a/Getting_Started_with_ESP-NOW_1.PNG","filters":[]}],"height":450.199203187251,"width":600}
|Description=<translate>Will guide you to communicate between ESP32 controllers by using ESP NOW protocol.</translate>
|Area=Electronics
|Type=Technique
|Difficulty=Easy
|Duration=1
|Duration-type=hour(s)
|Cost=10
|Currency=USD ($)
|Tags=ESP 32, ESP-NOW, Iot, Microcontrollers
}}
{{Introduction
|Introduction=<translate>ESP-NOW is a wireless communication protocol based on the data-link layer that enables the direct, quick, and low-power control of smart devices without the need for a router. Espressif defines it and can work with Wi-Fi and Bluetooth LE. ESP-NOW provides flexible and low-power data transmission to all interconnected devices. It can also be used as an independent protocol that helps with device provisioning, debugging, and firmware upgrades.

ESP-NOW is a connectionless communication protocol developed by Espressif that features short packet transmission. This protocol enables multiple devices to talk to each other in an easy way. It is a fast communication protocol that can be used to exchange small messages (up to 250 bytes) between ESP32 or ESP8266 boards. ESP-NOW supports the following features: Encrypted and unencrypted unicast communication; Mixed encrypted and unencrypted peer devices; Up to 250-byte payload can be carried; Sending callback function that can be set to inform the application layer of transmission success or failure.</translate>
}}
{{Materials
|Material=<translate></translate>
|Tools=<translate></translate>
}}
{{Tuto Step
|Step_Title=<translate>Get PCBs for Your Projects Manufactured</translate>
|Step_Content=<translate>You must check out [https://www.pcbway.com/ PCBWAY] for ordering PCBs online for cheap!

You get 10 good-quality PCBs manufactured and shipped to your doorstep for cheap. You will also get a discount on shipping on your first order. Upload your Gerber files onto [https://www.pcbway.com/ PCBWAY] to get them manufactured with good quality and quick turnaround time. PCBWay now could provide a complete product solution, from design to enclosure production. Check out their online Gerber viewer function. With reward points, you can get free stuff from their gift shop.</translate>
|Step_Picture_00=Getting_Started_with_ESP-NOW_2.PNG
}}
{{Tuto Step
|Step_Title=<translate>How is it different from existing protocols?</translate>
|Step_Content=<translate>[https://www.theengineeringprojects.com/2022/01/esp-now-protocol-with-esp32-and-esp8266.html ESP-NOW] is a wireless communication protocol that is different from Wi-Fi and Bluetooth in that it reduces the five layers of the OSI model to only one1. Additionally, ESP-NOW occupies fewer CPU and flash resources than traditional connection protocols while co-exists with Wi-Fi and Bluetooth LE.

Bluetooth is used to connect short-range devices for sharing information, while Wi-Fi is used for providing high-speed internet access2. Wi-Fi provides high bandwidth because the speed of the internet is an important issue.

===Max Distance: ===
The range of ESP-NOW is up to 480 meters when using the ESP-NOW protocol for bridging between multiple ESP32s1. The range can be further increased by enabling long-range ESP-NOW. When enabled, the PHY rate of ESP32 will be 512Kbps or 256Kbps.

===Maximum nodes: ===
ESP-NOW supports various series of Espressif chips, providing a flexible data transmission that is suitable for connecting “one-to-many” and “many-to-many” devices.

===Applications: ===
ESP-NOW is widely used in

*smart-home appliances,
*remote controlling,
*sensors, etc.

In this tutorial, will see how to implement a basic ESP NOW communication between ESP32 Microcontrollers.</translate>
|Step_Picture_00=Getting_Started_with_ESP-NOW_3_-_Copy.PNG
}}
{{Tuto Step
|Step_Title=<translate>Setting Up the Receiver</translate>
|Step_Content=<translate>ESPNOW communication works based on the MAC address of the nodes. So, we need to find the Mac address of our slave or receiver node.

]For that just upload the following sketch to the ESP32 board and look for the Mac address in the serial monitor.<syntaxhighlight>
#include "WiFi.h"

void setup(){
Serial.begin(115200);
WiFi.mode(WIFI_MODE_STA);
Serial.println(WiFi.macAddress());
}

void loop(){
}
</syntaxhighlight>

Once you uploaded the code, press the EN button and wait for the serial monitor results. It will show you the Mac address. Note that.</translate>
|Step_Picture_00=Getting_Started_with_ESP-NOW_4.PNG
|Step_Picture_01=Getting_Started_with_ESP-NOW_5.PNG
}}
{{Tuto Step
|Step_Title=<translate>Setting Up the Transmitter</translate>
|Step_Content=<translate>Next, we need to prepare the transmitter, for that use this example sketch which can send multiple data types of data to the particular slave node.<syntaxhighlight>

// 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, "I'm alive");
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);
}
</syntaxhighlight><blockquote>Note: Change the Mac Address here</blockquote>Here are the serial monitor results, it show sent success but not delivered. Because we don't have the receiver.

Let's try to implement the receiver.</translate>
|Step_Picture_00=Getting_Started_with_ESP-NOW_6.PNG
}}
{{Tuto Step
|Step_Title=<translate>Testing the Connection</translate>
|Step_Content=<translate>With the help of below example sketch, you can receive the data from the master and it will print that into the serial monitor.<syntaxhighlight>
#include <esp_now.h>
#include <WiFi.h>

// Structure example to receive data
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;
}

// get recv packer info
esp_now_register_recv_cb(OnDataRecv);
}

void loop() {

}
</syntaxhighlight>Serial monitor results.</translate>
|Step_Picture_00=Getting_Started_with_ESP-NOW_7.PNG
}}
{{Tuto Step
|Step_Title=<translate>Wrap Up:</translate>
|Step_Content=<translate><section id="story" data-origID="story" >
We have seen how to implement the ESP NOW in ESP32 microcontroller, in upcoming tutorials will see how to transmit sensor data via ESPNOW.
</section></translate>
}}
{{Notes
|Notes=<translate></translate>
}}
{{PageLang
|Language=en
|SourceLanguage=none
|IsTranslation=0
}}
{{Tuto Status
|Complete=Published
}}

Node Red Controlled Web LED on ESP32 with Raspberry Pi 4

2024-06-02T13:46:54Z

Simijames :

{{Tuto Details
|Main_Picture=Node_Red_Controlled_Web_LED_on_ESP32_with_Raspberry_Pi_4_1.PNG
|Main_Picture_annotation={"version":"2.4.6","objects":[{"type":"image","version":"2.4.6","originX":"left","originY":"top","left":-2,"top":-3,"width":749,"height":565,"fill":"rgb(0,0,0)","stroke":null,"strokeWidth":0,"strokeDashArray":null,"strokeLineCap":"butt","strokeDashOffset":0,"strokeLineJoin":"miter","strokeMiterLimit":4,"scaleX":0.8,"scaleY":0.8,"angle":0,"flipX":false,"flipY":false,"opacity":1,"shadow":null,"visible":true,"clipTo":null,"backgroundColor":"","fillRule":"nonzero","paintFirst":"fill","globalCompositeOperation":"source-over","transformMatrix":null,"skewX":0,"skewY":0,"crossOrigin":"","cropX":0,"cropY":0,"src":"https://wikifab.org/images/5/57/Node_Red_Controlled_Web_LED_on_ESP32_with_Raspberry_Pi_4_1.PNG","filters":[]}],"height":450.199203187251,"width":600}
|Description=<translate>Node Red Controlled Web LED on ESP32 with Raspberry Pi 4</translate>
|Area=Electronics
|Type=Technique
|Difficulty=Medium
|Duration=2
|Duration-type=hour(s)
|Cost=70
|Currency=USD ($)
|Tags=Raspberry Pi, Node Red, ESP 32, IoT, Qubitro
}}
{{Introduction
|Introduction=<translate>In this tutorial, you will learn how to use Node-RED, a visual programming tool for the Internet of Things (IoT), to control an LED on an ESP32 board with a Raspberry Pi as the MQTT broker. MQTT is a lightweight and simple messaging protocol that allows devices to communicate with each other over a network.

You will need the following components for this project:

*ESP32 development board
*USB cable to connect the ESP32 to your computer
*Raspberry Pi with Node-RED
*Computer with Arduino IDE and PubSubClient library installed</translate>
}}
{{Materials
|Material=<translate></translate>
|Tools=<translate></translate>
}}
{{Tuto Step
|Step_Title=<translate>Get PCBs For Your Projects Manufactured</translate>
|Step_Content=<translate>You must check out [https://www.pcbway.com/ PCBWAY] for ordering PCBs online for cheap!

You get 10 good-quality PCBs manufactured and shipped to your doorstep for cheap. You will also get a discount on shipping on your first order. Upload your Gerber files onto [https://www.pcbway.com/ PCBWAY] to get them manufactured with good quality and quick turnaround time. PCBWay now could provide a complete product solution, from design to enclosure production. Check out their online Gerber viewer function. With reward points, you can get free stuff from their gift shop</translate>
|Step_Picture_00=Node_Red_Controlled_Web_LED_on_ESP32_with_Raspberry_Pi_4_2.PNG
}}
{{Tuto Step
|Step_Title=<translate>Create a Device on Qubitro</translate>
|Step_Content=<translate>The first step is to create a device on the Qubitro platform. A device represents your physical device (Raspberry Pi) on the cloud. You need to create a device to obtain the MQTT credentials and topics for your Raspberry Pi.

To create a device on Qubitro, follow these steps:

1. Log in to your Qubitro account and create a new project

2. Then go to the Devices page, select MQTT as the communication protocol, and click Next.

3. Enter all the details.

4. Copy the Device ID, Device Token, Hostname, Port, Publish Topic, and Subscribe Topic. You will need these values later in the code. Click Finish.

You have successfully created a device on Qubitro. You can see your device on the Devices page.</translate>
|Step_Picture_00=Node_Red_Controlled_Web_LED_on_ESP32_with_Raspberry_Pi_4_3.PNG
|Step_Picture_01=Node_Red_Controlled_Web_LED_on_ESP32_with_Raspberry_Pi_4_4.PNG
|Step_Picture_02=Node_Red_Controlled_Web_LED_on_ESP32_with_Raspberry_Pi_4_5.PNG
|Step_Picture_03=Node_Red_Controlled_Web_LED_on_ESP32_with_Raspberry_Pi_4_6.PNG
|Step_Picture_04=Node_Red_Controlled_Web_LED_on_ESP32_with_Raspberry_Pi_4_7.PNG
}}
{{Tuto Step
|Step_Title=<translate>Flash ESP32 with Arduino IDE</translate>
|Step_Content=<translate>The ESP32 is a powerful and versatile microcontroller that can run Arduino code. You will use the Arduino IDE to program the ESP32 and make it communicate with the MQTT broker using the PubSubClient library.

To install the ESP32 board in Arduino IDE, you can follow the instructions in [https://blog.asksensors.com/esp32-led-control-iot-platform-mqtt/ this tutorial] or use the steps below:

*Open the preferences window from the Arduino IDE: File > Preferences.
*Go to the “Additional Board Manager URLs” field and enter the following URL: https://dl.espressif.com/dl/package_esp32_index.json.

*Open Boards Manager (Tools > Board > Boards Manager), search for ESP32, and click the install button for the “ESP32 by Espressif Systems”.

*Select your ESP32 board from Tools > Board menu after installation.

*Open the library manager from Sketch > Include Library > Manage Libraries.
*Search for PubSubClient and click the install button for the “PubSubClient by Nick O’Leary”.
*Restart your Arduino IDE after installation.</translate>
|Step_Picture_00=Node_Red_Controlled_Web_LED_on_ESP32_with_Raspberry_Pi_4_8.PNG
|Step_Picture_01=Node_Red_Controlled_Web_LED_on_ESP32_with_Raspberry_Pi_4_9.PNG
|Step_Picture_02=Node_Red_Controlled_Web_LED_on_ESP32_with_Raspberry_Pi_4_10.PNG
}}
{{Tuto Step
|Step_Title=<translate>Connect LED to ESP32</translate>
|Step_Content=<translate>The LED is a simple device that emits light when current flows through it. You will connect the LED to one of the GPIO pins of the ESP32 and control its state (on or off) with MQTT messages.

In my case I'm going to use the onboard LED in the ESP32 Dev board.</translate>
|Step_Picture_00=Node_Red_Controlled_Web_LED_on_ESP32_with_Raspberry_Pi_4_11.PNG
}}
{{Tuto Step
|Step_Title=<translate>Write Code for ESP32</translate>
|Step_Content=<translate>The code for the ESP32 will do the following tasks:

* Connect to your Wi-Fi network
* Connect to the Qubitro MQTT broker on Raspberry Pi
* Receive messages from “output” and turn on or off the LED accordingly

You can copy and paste the code below into your Arduino IDE. Make sure to replace <code><your_ssid></code>, <code><your_password></code>, <code><your_Qubtro_Credientials></code> with your own values.<syntaxhighlight>
void setup()
{

pinMode(Relay1, OUTPUT);
Serial.begin(115200);
setup_wifi();
client.setServer(mqtt_server, 1883);
client.setCallback(callback);
}

void loop()
{

if (!client.connected())
{
reconnect();
}
client. Loop();
}
</syntaxhighlight>After writing the code, upload it to your ESP32 board by selecting the right board and port from the Tools menu and clicking the upload button.</translate>
|Step_Picture_00=Node_Red_Controlled_Web_LED_on_ESP32_with_Raspberry_Pi_4_12.PNG
|Step_Picture_01=Node_Red_Controlled_Web_LED_on_ESP32_with_Raspberry_Pi_4_13.PNG
|Step_Picture_02=Node_Red_Controlled_Web_LED_on_ESP32_with_Raspberry_Pi_4_14.PNG
|Step_Picture_03=Node_Red_Controlled_Web_LED_on_ESP32_with_Raspberry_Pi_4_15.PNG
|Step_Picture_04=Node_Red_Controlled_Web_LED_on_ESP32_with_Raspberry_Pi_4_16.PNG
}}
{{Tuto Step
|Step_Title=<translate>Create Node-RED Flow</translate>
|Step_Content=<translate>The Node-RED flow will do the following tasks:

* Connect to the MQTT broker on Raspberry Pi
* Subscribe to a topic named “output”
* Publish messages “true” or “false” to a topic named “output”
* Create a dashboard with a button and a text node

You can create the Node-RED flow by dragging and dropping nodes from the palette and connecting them with wires. You can also import the flow from this link or use the JSON code below:<syntaxhighlight>
[
{
"id": "eb8f9c0d054be30c",
"type": "tab",
"label": "Flow 2",
"disabled": false,
"info": "",
"env": []
},
{
"id": "4ce6cd876fd5441f",
"type": "mqtt out",
"z": "eb8f9c0d054be30c",
"name": "",
"topic": "output",
"qos": "",
"retain": "",
"respTopic": "",
"contentType": "",
"userProps": "",
"correl": "",
"expiry": "",
"broker": "6d40b7b21c734b53",
"x": 870,
"y": 240,
"wires": []
},
{
"id": "974a7a8bb6db9bf9",
"type": "mqtt in",
"z": "eb8f9c0d054be30c",
"name": "",
"topic": "output",
"qos": "2",
"datatype": "auto-detect",
"broker": "6d40b7b21c734b53",
"nl": false,
"rap": true,
"rh": 0,
"inputs": 0,
"x": 670,
"y": 320,
"wires": [
[
"d0dc7378c7bfb03b",
"f1219a2eeabe825f"
]
]
},
{
"id": "d0dc7378c7bfb03b",
"type": "debug",
"z": "eb8f9c0d054be30c",
"name": "debug 4",
"active": true,
"tosidebar": true,
"console": false,
"tostatus": false,
"complete": "payload",
"targetType": "msg",
"statusVal": "",
"statusType": "auto",
"x": 880,
"y": 320,
"wires": []
},
{
"id": "6bd227b280e372b7",
"type": "ui_switch",
"z": "eb8f9c0d054be30c",
"name": "",
"label": "Light One",
"tooltip": "",
"group": "cd687a95.00e108",
"order": 0,
"width": 0,
"height": 0,
"passthru": true,
"decouple": "false",
"topic": "topic",
"topicType": "msg",
"style": "",
"onvalue": "true",
"onvalueType": "bool",
"onicon": "",
"oncolor": "",
"offvalue": "false",
"offvalueType": "bool",
"officon": "",
"offcolor": "",
"animate": false,
"x": 680,
"y": 240,
"wires": [
[
"4ce6cd876fd5441f"
]
]
},
{
"id": "f1219a2eeabe825f",
"type": "ui_text",
"z": "eb8f9c0d054be30c",
"group": "cd687a95.00e108",
"order": 1,
"width": "6",
"height": "2",
"name": "",
"label": "Status : ",
"format": "{{msg.payload}}",
"layout": "row-center",
"x": 1060,
"y": 320,
"wires": []
},
{
"id": "6d40b7b21c734b53",
"type": "mqtt-broker",
"name": "Qubitro Downlink",
"broker": "broker.qubitro.com",
"port": "1883",
"clientid": "",
"autoConnect": true,
"usetls": false,
"protocolVersion": "4",
"keepalive": "60",
"cleansession": true,
"autoUnsubscribe": true,
"birthTopic": "r43MsJYzcVwZtUXVfZo6XD0Ym7CRegewPQXMt$ho",
"birthQos": "0",
"birthPayload": "",
"birthMsg": {},
"closeTopic": "",
"closeQos": "0",
"closePayload": "",
"closeMsg": {},
"willTopic": "",
"willQos": "0",
"willPayload": "",
"willMsg": {},
"userProps": "",
"sessionExpiry": ""
},
{
"id": "cd687a95.00e108",
"type": "ui_group",
"name": "ESP32 Home Controller",
"tab": "aa146f4d.b53ca",
"order": 1,
"disp": true,
"width": "6",
"collapse": false
},
{
"id": "aa146f4d.b53ca",
"type": "ui_tab",
"name": "Demo Lab",
"icon": "dashboard",
"order": 1,
"disabled": false,
"hidden": false
}
]
</syntaxhighlight>The input switch will send "true" when it is on, and it will send "false" when it triggers off.

Then click on the Qubitro uplink pallet and edit the property.

Here you need to replace your connection details and credentials.

Next, just deploy the flow. And navigate to the /ui of the node-red server.

Here you can toggle the switch to turn the lead on and off.

Also, open the serial monitor and check the node-red response.</translate>
}}
{{Tuto Step
|Step_Title=<translate>Conclusion</translate>
|Step_Content=<translate><section id="story" data-origID="story" >
In this tutorial, we have seen how to control the LED with Node-Red and MQTT Server.
</section></translate>
|Step_Picture_00=Node_Red_Controlled_Web_LED_on_ESP32_with_Raspberry_Pi_4_17.PNG
}}
{{Notes
|Notes=<translate>Link was incorrect, so I have corrected it.</translate>
}}
{{PageLang
|Language=en
|SourceLanguage=none
|IsTranslation=0
}}
{{Tuto Status
|Complete=Published
}}