Guarda su YouTube

Tutorial ESP32 46/55 - Monitoraggio della temperatura remota utilizzando HiveMQ MQTT | Kit ESP32 di SunFounder

In questo tutorial, creeremo un sistema di monitoraggio della temperatura remota utilizzando l'ESP32 e il protocollo MQTT. Questo progetto ci consente di pubblicare i dati di temperatura su un broker MQTT e controllare un LED da remoto utilizzando un'interfaccia web. Premendo un pulsante, possiamo inviare le letture di temperatura al cloud e possiamo anche ricevere comandi per accendere o spegnere il LED.

L'ESP32 è un potente microcontrollore che presenta Wi-Fi e Bluetooth integrati, rendendolo ideale per applicazioni Internet of Things (IoT). In questa configurazione, utilizzeremo un termistore NTC per misurare la temperatura, un pulsante per attivare le letture e un LED per indicare lo stato. I dati verranno inviati a HiveMQ, un popolare broker MQTT, dove possono essere accessibili da remoto (nel video al 00:45).

Hardware Spiegato

Per questo progetto, utilizzeremo i seguenti componenti:

• Microcontrollore ESP32:Questa scheda funge da unità di elaborazione centrale, gestendo le connessioni Wi-Fi e le comunicazioni MQTT.
• Termistore NTC:Questo sensore di temperatura cambia la sua resistenza in base alla temperatura. Fornisce un segnale analogico che l'ESP32 può leggere per determinare la temperatura attuale.
• LED:Questo diodo a emissione di luce sarà utilizzato per indicare lo stato in base ai comandi ricevuti tramite MQTT.
• Pulsante:Questo pulsante attiverà l'ESP32 per leggere la temperatura e pubblicarla sul broker MQTT.

Dettagli del datasheet

• Garantire livelli di tensione adeguati per evitare danni.
• Utilizzare resistori di pull-up per il pulsante per garantire letture stabili.
• I condensatori di disaccoppiamento possono aiutare a stabilizzare l'alimentazione.
• Fai attenzione al cablaggio del termistore per evitare letture errate.
• Verifica i dettagli del tuo broker MQTT per una connessione riuscita.

Istruzioni di cablaggio

Per cablare i componenti, inizia collegando il termistore NTC. Collega un pin del termistore all'alimentazione di 3,3 V sull'ESP32. L'altro pin si collega al pin 36 dell'ESP32 e deve anche connettersi a una resistenza da 10 kΩ, che poi è collegata a terra. Questo crea un partitore di tensione che consente all'ESP32 di leggere la resistenza del termistore.

Successivamente, collega il LED. Il pin più lungo (anodo) del LED si collega al pin 4 dell'ESP32 tramite una resistenza da 220 Ω, mentre il pin più corto (catodo) si collega a terra. Per il pulsante, collega un lato a 3.3 V e l'altro lato al pin 14 dell'ESP32. Inoltre, collega una resistenza da 10 kΩ dal pin del pulsante a terra per garantire uno stato LOW stabile quando il pulsante non è premuto.

Installa la libreria richiesta

IlPubSubClientla libreria è utilizzata qui, puoi installarla daGestore della Biblioteca.

Esempi di codice e guida passo passo

Nella configurazione, inizializziamo la comunicazione seriale, impostiamo la connessione Wi-Fi e configuriamo il server MQTT. Ecco un estratto del codice di configurazione:

void setup() {
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
}

Questa parte del codice stabilisce la connessione alla rete Wi-Fi e configura il server MQTT. Anche le modalità dei pin per il pulsante e il LED sono configurate qui.

La funzione loop controlla continuamente lo stato del pulsante e pubblica i dati sulla temperatura quando viene premuto. Ecco un estratto concentrato dalla loop:

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
  if (digitalRead(buttonPin)) {
    long now = millis();
    if (now - lastMsg > 5000) {
      lastMsg = now;
      char tempString[8];
      dtostrf(thermistor(), 1, 2, tempString);
      client.publish("SF/TEMP", tempString);
    }
  }
}

In questo ciclo, controlliamo se l'ESP32 è connesso al broker MQTT. Se il pulsante viene premuto, legge la temperatura dal termistore e la pubblica nell'argomento "SF/TEMP" ogni 5 secondi.

Dimostrazione / Cosa Aspettarsi

Quando il progetto è configurato e in esecuzione, premere il pulsante pubblicherà la temperatura corrente al broker MQTT. Puoi monitorare questi dati da qualsiasi client MQTT. Inoltre, puoi inviare messaggi per controllare il LED; inviando "on" si accenderà, mentre "off" lo spegnerà. Guarda il comportamento atteso nel video alle 15:30, dove le letture della temperatura vengono mostrate dopo ogni pressione del pulsante.

Timestamp video

• 00:00 Inizio
• 2:05 Introduzione al progetto
• 7:06 Servizio HiveMQ gratuito
• 7:56 Spiegazione del cablaggio
• 11:11 Spiegazione del codice Arduino
• 18:46 Selezione della scheda ESP32 e della porta COM nell'Arduino IDE
• 20:30 Dimostrazione del broker HiveMQ Free

Immagini

esp32-47-mqt-1

esp32-47-mqt-2

esp32-47-mqtt-library

esp32-47-mqtt-wiring

esp32-47-mqt-1

esp32-47-mqt-2

esp32-47-mqtt-library

esp32-47-mqtt-wiring

/*
 * :ref: https://randomnerdtutorials.com/esp32-mqtt-publish-subscribe-arduino-ide/
 * https://docs.sunfounder.com/projects/kepler-kit/en/latest/iotproject/5.mqtt_pub.html
 */
#include <WiFi.h>
#include <PubSubClient.h>
 // #include <Wire.h>

 // Sostituisci le seguenti variabili con la tua combinazione SSID/Password
const char* ssid = "SSID";
const char* password = "PASSWORD";

 // Aggiungi l'indirizzo del tuo Broker MQTT, esempio:
const char* mqtt_server = "broker.hivemq.com";
const char* unique_identifier = "sunfounder-client-sdgvsda";

WiFiClient espClient;
PubSubClient client(espClient);
long lastMsg = 0;
int value = 0;


 // Pin LED
const int ledPin = 4;
const int buttonPin = 14;

 // Quando ti connetti al WIFI, solo i pin 36 39 34 35 32 33 possono essere utilizzati per la lettura analogica.
 // Definire costanti
const int thermistorPin = 36; // Pinnone connesso al termistore
const float referenceVoltage = 3.3;
const float referenceResistor = 10000; // Valore di resistenza (10k)
const float beta = 3950; // Valore Beta (Valore Tipico)
const float nominalTemperature = 25; // Temperatura nominale per il calcolo del coefficiente di temperatura
const float nominalResistance = 10000; // Valore di resistenza a temperatura nominale



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

 // impostazioni predefinite
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);

  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
}

void setup_wifi() {
  delay(10);
 // Iniziamo collegandoci a una rete WiFi.
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

void callback(char* topic, byte* message, unsigned int length) {
  Serial.print("Message arrived on topic: ");
  Serial.print(topic);
  Serial.print(". Message: ");
  String messageTemp;

  for (int i = 0; i < length; i++) {
    Serial.print((char)message[i]);
    messageTemp += (char)message[i];
  }
  Serial.println();

 // Se viene ricevuto un messaggio sull'argomento "SF/LED", controlli se il messaggio è "acceso" o "spento".
 // Cambia lo stato dell'output secondo il messaggio.
  if (String(topic) == "SF/LED") {
    Serial.print("Changing state to ");
    if (messageTemp == "on") {
      Serial.println("on");
      digitalWrite(ledPin, HIGH);
    } else if (messageTemp == "off") {
      Serial.println("off");
      digitalWrite(ledPin, LOW);
    }
  }
}

void reconnect() {
 // Ripeti fino a quando non siamo riconnessi
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
 // Tentativo di connessione
    if (client.connect(unique_identifier)) {
      Serial.println("connected");
 // Iscriviti
      client.subscribe("SF/LED");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
 // Aspetta 5 secondi prima di riprovare
      delay(5000);
    }
  }
}

float thermistor() {
  int adcValue = analogRead(thermistorPin); // Leggi il valore ADC
  float voltage = (adcValue * referenceVoltage) / 4095.0; // Calcola la tensione
  float resistance = (voltage * referenceResistor) / (referenceVoltage - voltage); // Calcola la resistenza del termistore con la configurazione aggiornata.

 // Calcola la temperatura utilizzando l'equazione del parametro Beta
  float tempK = 1 / (((log(resistance / nominalResistance)) / beta) + (1 / (nominalTemperature + 273.15)));

  float tempC = tempK - 273.15; // Ottieni la temperatura in gradi Celsius
  float tempF = 1.8 * tempC + 32.0; // Ottieni la temperatura in Fahrenheit

 // Stampa temperatura
  Serial.print("Temp: ");
  Serial.println(tempC);
  delay(200); // aspetta per 200 millisecondi
  return tempC;
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();

 // se il pulsante viene premuto, pubblica la temperatura sul tema "SF/TEMP"
  if (digitalRead(buttonPin)) {
    long now = millis();
    if (now - lastMsg > 5000) {
      lastMsg = now;
      char tempString[8];
      dtostrf(thermistor(), 1, 2, tempString);
      client.publish("SF/TEMP", tempString);
    }
  }
}