Integrazione del W5500 con ESP32 Utilizzando il Core 3: Supporto Nativo del Protocollo Ethernet con SSL e Altre Funzionalità
L’ESP32 è sempre stato una scelta popolare per i progetti IoT, grazie alle sue robuste capacità Wi-Fi. Tuttavia, con il nuovo rilascio di Core 3, l’ESP32 supporta ora i protocolli Ethernet nativi con SSL, ampliando la sua utilità per applicazioni di rete cablate. Questo articolo esplora come integrare il modulo Ethernet W5500 con l’ESP32 utilizzando il nuovo Core 3, descrivendo l’installazione, la configurazione e le applicazioni pratiche.
Introduzione
L’ESP32, con il suo processore dual-core e le sue opzioni di connettività versatili, è ideale per una vasta gamma di applicazioni IoT. Il rilascio del Core 3 ha introdotto il supporto nativo per i protocolli Ethernet, rendendo più facile sfruttare le connessioni cablate con le stesse funzionalità del Wi-Fi, inclusi SSL/TLS. Questa guida si concentra sull’uso del modulo Ethernet W5500 con l’ESP32, fornendo connettività di rete sicura e affidabile.
Requisiti Hardware
Per iniziare, avrai bisogno dei seguenti componenti:
- Scheda di sviluppo ESP32
Ecco la mia selezione di ESP32 ESP32 Dev Kit v1 - TTGO T-Display 1.14 ESP32 - NodeMCU V3 V2 ESP8266 Lolin32 - NodeMCU ESP-32S - WeMos Lolin32 - WeMos Lolin32 mini - ESP32-CAM programmer - ESP32-CAM bundle - ESP32-WROOM-32 - ESP32-S
Ecco la mia selezione di ESP32-S3 ESP32 S3 Purlple AI-S3 - YD-ESP32-S3 - ESP32-S3-DevKitC-1 - ESP32-S3-DevKitC-1 - ESP32-S3 Board screen
- Modulo Ethernet W5500
- Cavi jumper
- Breadboard (opzionale)
Dispositivi
Il chip W5500 è un controller Ethernet TCP/IP cablato integrato che fornisce una connessione Internet semplificata ai sistemi embedded. Il W5500 consente agli utenti di avere connettività Internet nelle loro applicazioni utilizzando un singolo chip in cui sono integrati lo stack TCP/IP, il MAC Ethernet 10/100 e il PHY.
La tecnologia TCP/IP cablata di WIZnet è una soluzione collaudata sul mercato che supporta i protocolli TCP, UDP, IPv4, ICMP, ARP, IGMP e PPPoE. Il W5500 include un buffer di memoria interno da 32 Kbyte per l’elaborazione dei pacchetti Ethernet. Con il W5500, è possibile implementare applicazioni Ethernet aggiungendo un semplice programma socket. È un metodo più veloce e semplice rispetto a qualsiasi altra soluzione Ethernet embedded. Gli utenti possono utilizzare otto socket hardware indipendenti simultaneamente.
L’interfaccia SPI (Serial Peripheral Interface) è fornita per una facile integrazione con il microcontrollore esterno. L’SPI del W5500 supporta una velocità di 80 MHz. Per ridurre il consumo energetico del sistema, il W5500 fornisce la modalità WOL (Wake on LAN) e power-down.
Caratteristiche
- Supporto per i protocolli TCP/IP cablati: TCP, UDP, ICMP, IPv4, ARP, IGMP, PPPoE
- Supporta 8 socket indipendenti simultaneamente
- Supporta la modalità di spegnimento
- Supporta Wake on LAN tramite UDP
- Supporta interfaccia SPI ad alta velocità (SPI MODE 0, 3)
- Memoria interna da 32 Kbyte per buffer TX/RX
- PHY Ethernet 10BaseT/100BaseTX integrato
- Supporta la negoziazione automatica (full e half duplex, 10 e 100 Mbps)
- Non supporta la frammentazione IP
- Funzionamento a 3,3 V con tolleranza ai segnali I/O a 5 V
- Uscite LED (Full/Half duplex, Link, Speed, Active)
- Pacchetto LQFP senza piombo a 48 pin (7×7 mm, passo 0,5 mm)
Esiste una vasta gamma di dispositivi W5500, ma i più popolari sono 2 in particolare.
Il meno costoso è il W5500 che puoi vedere nella foto.
Ora c’è una versione compatta chiamata W5500 lite, molto interessante come dispositivo di produzione.
Ecco la mia selezione di dispositivi Ethernet testati w5500 lite - w5500 - enc26j60 mini - enc26j60 - lan8720
Collegamento del W5500 all’ESP32-S3
Un cablaggio corretto garantisce una comunicazione stabile tra l’ESP32 e il modulo W5500. Di seguito sono riportati i collegamenti dei pin. Per questo test, utilizzeremo un ESP32-S3.
Ecco la mia selezione di ESP32-S3 ESP32 S3 Purlple AI-S3 - YD-ESP32-S3 - ESP32-S3-DevKitC-1 - ESP32-S3-DevKitC-1 - ESP32-S3 Board screen
Schema di collegamento mini W5500
Schema di collegamento W5500
| ESP32-S3 | W5500/W5500 Mini |
|---|---|
| GPIO13 | MISO |
| GPIO12 | SCLK |
| GPIO11 | MOSI |
| GPIO10 | CS |
| GPIO9 (opzionale) | INT |
| GPIO3 (opzionale) | RST |
| 3v3 | 3v3 |
| GND | GND |
// Imposta questo valore a 1 per abilitare il supporto Ethernet doppio
#define USE_TWO_ETH_PORTS 0
#define ETH_PHY_TYPE ETH_PHY_W5500
#define ETH_PHY_ADDR 1
#define ETH_PHY_CS 10
#define ETH_PHY_IRQ 9 // -1 se non sarà cablato
#define ETH_PHY_RST 3 // -1 se non sarà cablato
// Pin SPI
#define ETH_SPI_SCK SCK
#define ETH_SPI_MISO MISO
#define ETH_SPI_MOSI MOSI
Assicurati che i pin siano collegati come specificato. Questa configurazione garantisce che l’ESP32 possa comunicare con il modulo W5500 tramite SPI.
Wiring the W5500 to ESP32
Un cablaggio corretto assicura una comunicazione stabile tra l’ESP32 e il modulo W5500. Di seguito sono riportate le connessioni dei pin.
Ecco la mia selezione di esp32 ESP32 Dev Kit v1 - TTGO T-Display 1.14 ESP32 - NodeMCU V3 V2 ESP8266 Lolin32 - NodeMCU ESP-32S - WeMos Lolin32 - WeMos Lolin32 mini - ESP32-CAM programmer - ESP32-CAM bundle - ESP32-WROOM-32 - ESP32-S
Mini w5500 collegamento
w5500 collegamento
| esp32 | w5500/w5500 mini |
|---|---|
| GPIO19 | MISO |
| GPIO18 | SCLK |
| GPIO23 | MOSI |
| GPIO5 | CS |
| GPIO15 (optional) | INT |
| GPIO4 (optional) | RST |
| 3v3 | 3v3 |
| GND | GND |
// Set this to 1 to enable dual Ethernet support
#define USE_TWO_ETH_PORTS 0
#define ETH_PHY_TYPE ETH_PHY_W5500
#define ETH_PHY_ADDR 1
#define ETH_PHY_CS 5
#define ETH_PHY_IRQ 15 // -1 if you won't wire
#define ETH_PHY_RST 4 // -1 if you won't wire
// SPI pins
#define ETH_SPI_SCK SCK
#define ETH_SPI_MISO MISO
#define ETH_SPI_MOSI MOSI
Assicuratevi che i pin siano collegati come specificato. Questa configurazione assicura che l’ESP32 possa comunicare con il modulo W5500 tramite SPI.
Configurazione dei collegamenti Ethernet
Configura le impostazioni Ethernet nel tuo sketch.
SPI.begin(ETH_SPI_SCK, ETH_SPI_MISO, ETH_SPI_MOSI);
ETH.begin(ETH_PHY_TYPE, ETH_PHY_ADDR, ETH_PHY_CS, ETH_PHY_IRQ, ETH_PHY_RST, SPI);
Usa la funzione Network.onEvent per sapere quando siamo pronti per effettuare una richiesta.
Network.onEvent(onEvent);
È necessario creare una funzione per gestire l’evento di connessione o per monitorare tutti gli stati della rete.
void onEvent(arduino_event_id_t event, arduino_event_info_t info)
{
switch (event) {
case ARDUINO_EVENT_ETH_START:
Serial.println("ETH Started");
//set eth hostname here
ETH.setHostname("esp32-eth0");
break;
case ARDUINO_EVENT_ETH_CONNECTED:
Serial.println("ETH Connected");
break;
case ARDUINO_EVENT_ETH_GOT_IP:
Serial.printf("ETH Got IP: '%s'\n", esp_netif_get_desc(info.got_ip.esp_netif));
Serial.println(ETH);
eth_connected = true;
break;
case ARDUINO_EVENT_ETH_LOST_IP:
Serial.println("ETH Lost IP");
eth_connected = false;
break;
case ARDUINO_EVENT_ETH_DISCONNECTED:
Serial.println("ETH Disconnected");
eth_connected = false;
break;
case ARDUINO_EVENT_ETH_STOP:
Serial.println("ETH Stopped");
eth_connected = false;
break;
default:
break;
}
}
Dopo la connessione, saremo pronti a eseguire le operazioni necessarie.
Richiesta HTTP semplice
Per cominciare, proveremo a fare una semplice richiesta HTTP. Ho scelto un servizio online creato per testare questo tipo di richiesta.
Sto per utilizzare un servizio semplice fornito da httpbin.org, e puoi usare le stesse API REST in HTTP e HTTPS.
Ricorda che HTTP lavora sulla porta 80 e HTTPS sulla 443, quindi per interrogare l’endpoint sulla porta 443 devi convalidare un certificato.
Proviamo quindi a connetterci e a richiedere un endpoint con GET.
// Test client connection
void testClient(const char * host, uint16_t port)
{
Serial.print("\nconnecting to ");
Serial.println(host);
NetworkClient client;
if (!client.connect(host, port)) {
Serial.println("connection failed");
return;
}
client.println("GET /get HTTP/1.1");
client.println("Host: httpbin.org");
client.println("Connection: close");
client.println();
while (client.connected() && !client.available());
while (client.available()) {
Serial.write(client.read());
}
Serial.println("closing connection\n");
client.stop();
}
Ricorda di fare la richiesta dopo che il modulo ha completato l’handshake.
void loop()
{
if (eth_connected) {
testClient("httpbin.org", 80);
}
delay(10000);
}
E infine, lo sketch completo.
/*
* Author: Renzo Mischianti
* Website: mischianti.org
* Description: This sketch demonstrates how to set up and use Ethernet on an ESP32 module using the W5500 Ethernet module.
* The sketch initializes the Ethernet module, handles Ethernet events, and tests a simple client connection.
*/
#include "Arduino.h"
#include <ETH.h>
#include <SPI.h>
// Set this to 1 to enable dual Ethernet support
#define USE_TWO_ETH_PORTS 0
// #ifndef ETH_PHY_TYPE
#define ETH_PHY_TYPE ETH_PHY_W5500
#define ETH_PHY_ADDR 1
#define ETH_PHY_CS 5 // CS esp32s3 10 esp32 5
#define ETH_PHY_IRQ -1 // 9 15
#define ETH_PHY_RST -1 // 3 4
// #endif
// SPI pins esp32s3 esp32
#define ETH_SPI_SCK SCK // 12 18
#define ETH_SPI_MISO MISO // 13 19
#define ETH_SPI_MOSI MOSI // 11 23
static bool eth_connected = false;
// Ethernet event handler
void onEvent(arduino_event_id_t event, arduino_event_info_t info)
{
switch (event) {
case ARDUINO_EVENT_ETH_START:
Serial.println("ETH Started");
// Set Ethernet hostname here
ETH.setHostname("esp32-eth0");
break;
case ARDUINO_EVENT_ETH_CONNECTED:
Serial.println("ETH Connected");
break;
case ARDUINO_EVENT_ETH_GOT_IP:
Serial.printf("ETH Got IP: '%s'\n", esp_netif_get_desc(info.got_ip.esp_netif));
Serial.println(ETH);
eth_connected = true;
break;
case ARDUINO_EVENT_ETH_LOST_IP:
Serial.println("ETH Lost IP");
eth_connected = false;
break;
case ARDUINO_EVENT_ETH_DISCONNECTED:
Serial.println("ETH Disconnected");
eth_connected = false;
break;
case ARDUINO_EVENT_ETH_STOP:
Serial.println("ETH Stopped");
eth_connected = false;
break;
default:
break;
}
}
// Test client connection
void testClient(const char * host, uint16_t port)
{
Serial.print("\nconnecting to ");
Serial.println(host);
NetworkClient client;
if (!client.connect(host, port)) {
Serial.println("connection failed");
return;
}
client.println("GET /get HTTP/1.1");
client.println("Host: httpbin.org");
client.println("Connection: close");
client.println();
while (client.connected() && !client.available());
while (client.available()) {
Serial.write(client.read());
}
Serial.println("closing connection\n");
client.stop();
}
void setup()
{
Serial.begin(115200);
Network.onEvent(onEvent);
SPI.begin(ETH_SPI_SCK, ETH_SPI_MISO, ETH_SPI_MOSI, ETH_PHY_CS);
ETH.begin(ETH_PHY_TYPE, ETH_PHY_ADDR, ETH_PHY_CS, ETH_PHY_IRQ, ETH_PHY_RST, SPI);
}
void loop()
{
if (eth_connected) {
testClient("httpbin.org", 80);
}
delay(10000);
}
Il risultato sarà il seguente:
ETH Started
ETH Connected
ETH Got IP: 'eth0'
*eth0: <UP,100M,FULL_DUPLEX,AUTO,ADDR:0x1> (DHCPC,GARP,IP_MOD)
ether 32:AE:A4:F5:01:C0
inet 192.168.1.137 netmask 255.255.255.0 broadcast 192.168.1.255
gateway 192.168.1.1 dns 192.168.1.10
connecting to httpbin.org
HTTP/1.1 200 OK
Date: Mon, 22 Jul 2024 07:54:20 GMT
Content-Type: application/json
Content-Length: 199
Connection: close
Server: gunicorn/19.9.0
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true
{
"args": {},
"headers": {
"Host": "httpbin.org",
"X-Amzn-Trace-Id": "Root=1-669e102c-1868445a1fafaaf7199a5fe3"
},
"origin": "84.221.199.122",
"url": "http://httpbin.org/get"
}
closing connection
Richiesta HTTPS
Ora, se cambiamo l’endpoint alla porta 443, faremo una richiesta a un server sicuro con crittografia SSL.
// Test client connection
void testClient(const char * host, uint16_t port)
{
Serial.print("\nconnecting to ");
Serial.println(host);
NetworkClientSecure client;
client.setInsecure();
if (!client.connect(host, port)) {
Serial.println("connection failed");
return;
}
client.println("GET /get HTTP/1.1");
client.println("Host: httpbin.org");
client.println("Connection: close");
client.println();
while (client.connected() && !client.available());
while (client.available()) {
Serial.write(client.read());
}
Serial.println("closing connection\n");
client.stop();
}
Se non imposti la modalità insicura, non puoi connetterti e riceverai un messaggio come questo:
ETH Started
ETH Connected
ETH Got IP: 'eth0'
*eth0: <UP,100M,FULL_DUPLEX,AUTO,ADDR:0x1> (DHCPC,GARP,IP_MOD)
ether B8:D6:1A:68:E5:7F
inet 192.168.1.146 netmask 255.255.255.0 broadcast 192.168.1.255
gateway 192.168.1.1 dns 192.168.1.10
connecting to httpbin.org
connection failed
Usiamo la porta 443 per la connessione HTTPS sicura.
void loop()
{
if (eth_connected) {
testClient("httpbin.org", 443);
}
delay(10000);
}
Ecco lo sketch completo per la richiesta HTTPS.
/*
* Author: Renzo Mischianti
* Website: mischianti.org
* Description: This sketch demonstrates how to set up and use Ethernet on an ESP32 module using the W5500 Ethernet module.
* The sketch initializes the Ethernet module, handles Ethernet events, and tests a simple client HTTPS connection.
*/
#include "Arduino.h"
#include <ETH.h>
#include <SPI.h>
#include <NetworkClientSecure.h>
// Set this to 1 to enable dual Ethernet support
#define USE_TWO_ETH_PORTS 0
// #ifndef ETH_PHY_TYPE
#define ETH_PHY_TYPE ETH_PHY_W5500
#define ETH_PHY_ADDR 1
#define ETH_PHY_CS 5 // CS esp32s3 10 esp32 5
#define ETH_PHY_IRQ -1 // 9 15
#define ETH_PHY_RST -1 // 3 4
// #endif
// SPI pins esp32s3 esp32
#define ETH_SPI_SCK SCK // 12 18
#define ETH_SPI_MISO MISO // 13 19
#define ETH_SPI_MOSI MOSI // 11 23
static bool eth_connected = false;
// Ethernet event handler
void onEvent(arduino_event_id_t event, arduino_event_info_t info)
{
switch (event) {
case ARDUINO_EVENT_ETH_START:
Serial.println("ETH Started");
// Set Ethernet hostname here
ETH.setHostname("esp32-eth0");
break;
case ARDUINO_EVENT_ETH_CONNECTED:
Serial.println("ETH Connected");
break;
case ARDUINO_EVENT_ETH_GOT_IP:
Serial.printf("ETH Got IP: '%s'\n", esp_netif_get_desc(info.got_ip.esp_netif));
Serial.println(ETH);
eth_connected = true;
break;
case ARDUINO_EVENT_ETH_LOST_IP:
Serial.println("ETH Lost IP");
eth_connected = false;
break;
case ARDUINO_EVENT_ETH_DISCONNECTED:
Serial.println("ETH Disconnected");
eth_connected = false;
break;
case ARDUINO_EVENT_ETH_STOP:
Serial.println("ETH Stopped");
eth_connected = false;
break;
default:
break;
}
}
// Test client connection
void testClient(const char * host, uint16_t port)
{
Serial.print("\nconnecting to ");
Serial.println(host);
NetworkClientSecure client;
client.setInsecure();
if (!client.connect(host, port)) {
Serial.println("connection failed");
return;
}
client.println("GET /get HTTP/1.1");
client.println("Host: httpbin.org");
client.println("Connection: close");
client.println();
while (client.connected() && !client.available());
while (client.available()) {
Serial.write(client.read());
}
Serial.println("closing connection\n");
client.stop();
}
void setup()
{
Serial.begin(115200);
Network.onEvent(onEvent);
SPI.begin(ETH_SPI_SCK, ETH_SPI_MISO, ETH_SPI_MOSI, ETH_PHY_CS);
ETH.begin(ETH_PHY_TYPE, ETH_PHY_ADDR, ETH_PHY_CS, ETH_PHY_IRQ, ETH_PHY_RST, SPI);
}
void loop()
{
if (eth_connected) {
testClient("httpbin.org", 443);
}
delay(10000);
}
Ora, quando eseguiamo lo sketch, otteniamo questo output:
ETH Started
ETH Connected
ETH Got IP: 'eth0'
*eth0: <UP,100M,FULL_DUPLEX,AUTO,ADDR:0x1> (DHCPC,GARP,IP_MOD)
ether 32:AE:A4:F5:01:C0
inet 192.168.1.137 netmask 255.255.255.0 broadcast 192.168.1.255
gateway 192.168.1.1 dns 192.168.1.10
connecting to httpbin.org
HTTP/1.1 200 OK
Date: Mon, 22 Jul 2024 10:10:17 GMT
Content-Type: application/json
Content-Length: 200
Connection: close
Server: gunicorn/19.9.0
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true
{
"args": {},
"headers": {
"Host": "httpbin.org",
"X-Amzn-Trace-Id": "Root=1-669e3009-5b117fd9360750c0582e7b17"
},
"origin": "84.221.199.122",
"url": "https://httpbin.org/get"
}
ÿclosing connection
Recupero del certificato
Come puoi vedere, per il test ho usato la modalità insicura:
NetworkClientSecure client;
client.setInsecure();
La cosa corretta da fare è recuperare il certificato dell’Autorità di Certificazione (CA) per convalidare l’host.
Quindi, sulla pagina di httpbin, clicca sulle impostazioni del sito.
Quindi, seleziona le informazioni sulla connessione.
Ora clicca sul certificato.
Infine, seleziona la linea in alto nell’elenco (il certificato radice).
Esporta il certificato, apri il file, copia il contenuto e inseriscilo in una variabile di tipo array di caratteri.
const char* rootCA= R""""(-----BEGIN CERTIFICATE-----
MIIDQTCCAimgAwIBAgITBmyfz5m/jAo54vB4ikPmljZbyjANBgkqhkiG9w0BAQsF
ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6
b24gUm9vdCBDQSAxMB4XDTE1MDUyNjAwMDAwMFoXDTM4MDExNzAwMDAwMFowOTEL
MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv
b3QgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALJ4gHHKeNXj
ca9HgFB0fW7Y14h29Jlo91ghYPl0hAEvrAIthtOgQ3pOsqTQNroBvo3bSMgHFzZM
9O6II8c+6zf1tRn4SWiw3te5djgdYZ6k/oI2peVKVuRF4fn9tBb6dNqcmzU5L/qw
IFAGbHrQgLKm+a/sRxmPUDgH3KKHOVj4utWp+UhnMJbulHheb4mjUcAwhmahRWa6
VOujw5H5SNz/0egwLX0tdHA114gk957EWW67c4cX8jJGKLhD+rcdqsq08p8kDi1L
93FcXmn/6pUCyziKrlA4b9v7LWIbxcceVOF34GfID5yHI9Y/QCB/IIDEgEw+OyQm
jgSubJrIqg0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC
AYYwHQYDVR0OBBYEFIQYzIU07LwMlJQuCFmcx7IQTgoIMA0GCSqGSIb3DQEBCwUA
A4IBAQCY8jdaQZChGsV2USggNiMOruYou6r4lK5IpDB/G/wkjUu0yKGX9rbxenDI
U5PMCCjjmCXPI6T53iHTfIUJrU6adTrCC2qJeHZERxhlbI1Bjjt/msv0tadQ1wUs
N+gDS63pYaACbvXy8MWy7Vu33PqUXHeeE6V/Uq2V8viTO96LXFvKWlJbYK8U90vv
o/ufQJVtMVT8QtPHRh8jrdkPSHCa2XV4cdFyQzR1bldZwgJcJmApzyMZFo6IQ6XU
5MsI+yMRQ+hDKXJioaldXgjUkK642M4UwtBV8ob2xJNDd2ZhwLnoQdeXeGADbkpy
rqXRfboQnoZsG4q5WTP468SQvvG5
-----END CERTIFICATE-----)"""";
Ora possiamo impostare il certificato dell’Autorità di Certificazione (CA) per convalidare il server httpbin al NetworkClientSecure.
NetworkClientSecure client;
client.setCACert(rootCA);
Conclusione
Integrare il modulo Ethernet W5500 con l’ESP32 utilizzando Core 3 amplia le capacità dei tuoi progetti IoT fornendo una connettività di rete cablata robusta e sicura. Con il supporto nativo per i protocolli Ethernet, SSL/TLS e altre funzionalità, puoi sfruttare appieno il potenziale dell’ESP32 per una vasta gamma di applicazioni.
- ESP32: piedinatura, specifiche e configurazione dell’Arduino IDE
- ESP32: fileSystem integrato SPIFFS
- ESP32: gestire più seriali e logging per il debug
- ESP32 risparmio energetico pratico
- ESP32 risparmio energetico pratico: gestire WiFi e CPU
- ESP32 risparmio energetico pratico: modem e light sleep
- ESP32 risparmio energetico pratico: deep sleep e ibernazione
- ESP32 risparmio energetico pratico: preservare dati al riavvio, sveglia a tempo e tramite tocco
- ESP32 risparmio energetico pratico: sveglia esterna e da ULP
- ESP32 risparmio energetico pratico: sveglia da UART e GPIO
- ESP32: filesystem integrato LittleFS
- ESP32: filesystem integrato FFat (Fat/exFAT)
- ESP32-wroom-32
- ESP32-CAM
- ESP32: ethernet w5500 con chiamate standard (HTTP) e SSL (HTTPS)
- ESP32: ethernet enc28j60 con chiamate standard (HTTP) e SSL (HTTPS)
- Come usare la scheda SD con l’esp32
- esp32 e esp8266: file system FAT su memoria SPI flash esterna
- Gestione aggiornamenti firmware e OTA
- Gestione del firmware
- Aggiornamento OTA con Arduino IDE
- Aggiornamento OTA con browser web
- Aggiornamenti automatici OTA da un server HTTP
- Aggiornamento del firmware non standard
- Integrare LAN8720 con ESP32 per la connettività Ethernet con plain (HTTP) e SSL (HTTPS)
- Collegare l’EByte E70 (CC1310) ai dispositivi ESP32 c3/s3 ed un semplice sketch di esempio
- ESP32-C3: piedinatura, specifiche e configurazione dell’IDE Arduino
- Integrazione del modulo W5500 su ESP32 con Core 3: supporto nativo ai protocolli Ethernet con SSL e altre funzionalità
- Integrazione del modulo LAN8720 su ESP32 con Core 3: supporto nativo del protocollo Ethernet con SSL e altre funzionalità.
- Dallas DS18B20
- Dallas DS18B20 con ESP32 ed ESP8266: introduzione e modalità parasita
- Dallas DS18B20 con ESP32 ed ESP8266: gate P-MOSFET pull-up e allarmi
- Dallas DS18B20 con ESP32 ed ESP8266: tutte le topologie OneWire, lunghe derivazioni e più dispositivi
