Site icon Renzo Mischianti

Dallas DS18B20 con ESP32 ed ESP8266: pull-up sul gate del P-MOSFET e allarmi

Dallas ds18b20 con esp32 e esp8266: gate P-MOSFET pull-up e allarmi

Dallas ds18b20 con esp32 e esp8266: gate P-MOSFET pull-up e allarmi

Spread the love

Il Dallas ds18b20 è un termometro digitale che fornisce letture accurate della temperatura con requisiti hardware minimi.

Quando accoppiato con il microcontrollore ESP32, diventa uno strumento potente per il monitoraggio della temperatura e per l’attivazione di allarmi basati su condizioni preimpostate.

Dallas ds18b20 con ESP32: pull-up sul gate del P-MOSFET e allarme

Tuttavia, per garantire il corretto funzionamento del ds18b20, è necessario un resistore pull-up. In questo articolo, esploreremo come utilizzare il gate di un P-MOSFET come resistore pull-up per il ds18b20 e come configurare allarmi di temperatura con l’ESP32.

Che tu sia un hobbista o un professionista in cerca di integrare il monitoraggio della temperatura nei tuoi progetti, questo articolo fornirà una guida completa all’utilizzo del ds18b20 con l’ESP32.

Caratteristiche

Scheda tecnica

Pinout

Pinout del Dallas ds18b20

Il sensore ha diverse varianti, ma il cablaggio rimane lo stesso.

GND: connetti a GND.
DATA: bus dati One-Wire.
VCC: alimentazione (3,3 – 5 V), ma in modalità parassita puoi collegarlo a GND.

Qui il sensore AliExpress

Problemi della modalità parassita

Il protocollo di comunicazione 1-Wire non solo facilita la comunicazione, ma fornisce anche energia operativa per gli slave. Gli slave prelevano energia dal bus quando la tensione sul bus è superiore a quella del loro condensatore interno di accumulo.

Tuttavia, in reti con troppi slave, la corrente fornita dal master potrebbe non essere sufficiente a mantenere la tensione operativa negli slave, causando guasti intermittenti che dipendono dai dati.

esp32: schema di cablaggio del ds18b20 in modalità parassita con pull-up forte

Lo scenario peggiore per l’energia parassita è una lunga sequenza di bit zero emessa dal master, poiché il bus trascorre la maggior parte del tempo in stato basso e vi è poca opportunità di ricaricare gli slave.

Man mano che la tensione in ogni slave diminuisce, la capacità dello slave di pilotare il bus si riduce, portando infine a uno stato di reset in cui lo slave smette di rispondere.

Quando lo slave riceve nuovamente una tensione operativa sufficiente, emetterà un impulso di presenza, che può corrompere altre attività sul bus.

Una possibile soluzione è mostrata nell’immagine sopra: il bus 1-Wire deve essere commutato sul pull-up forte entro 10µs (massimo) dopo le conversioni di temperatura, e il bus deve essere mantenuto alto dal pull-up per tutta la durata della conversione o del trasferimento dei dati. Nessuna altra attività può aver luogo sul bus 1-Wire mentre il pull-up è abilitato.

Il DS18B20 può anche essere alimentato con il metodo convenzionale di collegare una fonte di alimentazione esterna al pin VDD, come mostrato. Il vantaggio di questo metodo è che il pull-up MOSFET non è necessario, e il bus 1-Wire è libero di trasportare altri dati durante il tempo di conversione della temperatura.

Cablaggio

La libreria One-Wire è uno standard per tutti i microcontrollori, perciò il dispositivo può essere utilizzato con molti microcontrollori. Abbiamo già mostrato il collegamento di un singolo sensore, e ora collegheremo e gestiremo più sensori.

Se devi collegare un solo sensore, fai riferimento all’articolo precedente, “Dallas ds18b20 con ESP32: introduzione e modalità parassita”.

esp32

Qui trovi il pinout di una delle schede prototipo ESP32 più comuni.

ESP32 DOIT DEV KIT v1 pinout

Qui 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

Modalità normale

In modalità normale, utilizzeremo una linea di alimentazione a 3,3V, quindi il collegamento sarà il seguente.

ESP32 con ds18b20 waterproof: cablaggio su breadboard

Il collegamento è molto semplice.

esp32ds18b20
GNDGND
3.3VVCC
D22 con pull-upDATA

Modalità parassita

In modalità parassita, collegherai GND anche alla linea VCC del sensore, il quale preleverà l’alimentazione dalla linea DATA.

ESP32 con ds18b20 in modalità parassita: cablaggio su breadboard
esp32ds18b20
GNDGND
GNDVCC
D22 con pull-upDATA

esp8266

Modalità normale

Cablaggio WeMos D1 ESP8266 e ds18b20
esp8266ds18b20
GNDGND
3.3VVCC
D2 con pull-upDATA

Modalità parassita

ESP8266 e ds18b20 in modalità parassita
esp8266ds18b20
GNDGND
GNDVCC
D2 con pull-upDATA

Gate P-MOSFET per pull-up forte

L’utilizzo di un P-MOSFET realizza il pull-up forte. Ecco un semplice esempio di cablaggio.

ESP32: cablaggio del ds18b20 waterproof in modalità parassita con pull-up forte
esp32ds18b20
GNDGND
GNDVCC
D22 con pull-upDATA
esp32P-MOSFETds18b20
D21Gate
VCCSource
DrainDATA

Per un circuito 1-wire con pull-up forte, il MOSFET deve essere collegato come segue:

  1. Il drain del MOSFET deve essere collegato alla linea dati 1-wire del dispositivo, ossia al collegamento del ds18b20.
  2. La source del MOSFET deve essere collegata a una tensione di alimentazione positiva.
  3. Il gate del MOSFET deve essere collegato a un pin del microcontrollore (ad es. ESP32) configurato come uscita.
  4. Il pin del microcontrollore che controlla il gate del MOSFET deve essere impostato su HIGH per attivare il pull-up forte e su LOW per disattivarlo.

È importante notare che il pull-up forte deve essere attivato solo quando il microcontrollore deve leggere i dati dal ds18b20. Quando non si stanno leggendo dati, il pull-up forte va disattivato per evitare il surriscaldamento del ds18b20.

Libreria

Prima di tutto, devi ricordare che questo sensore utilizza il protocollo One-Wire, quindi è necessario aggiungere la libreria OneWire.

Ogni piattaforma la possiede; spiegheremo meglio questo protocollo quando introdurremo l’uso di più sensori.

Arduino IDE: libreria OneWire nel gestore delle librerie

Dopo di che, devi installare una libreria che implementi il protocollo e le funzionalità del sensore.

Ho scelto la più diffusa, la DallasTemperature (in passato Dallas, ora Maxim).

Arduino IDE: libreria DallasTemperature per il ds18b20 dal libraries manager

Dispositivi supportati

Come descritto nel repository, questa libreria supporta i seguenti dispositivi:

Avrai bisogno di un resistore pull-up di circa 4.7KOhm tra la linea dati 1-Wire e il tuo VCC. Se usi il DS18B20, puoi utilizzare la modalità parassita, collegando il VCC a GND come descritto.

Risoluzione dei problemi

In caso di problemi nella conversione della temperatura (il risultato è -85), potrebbe essere necessario un setup con pull-up forte. Vedi la sezione Powering the DS18B20 nel datasheet del DS18B20 (pagina 7) e utilizza il costruttore DallasTemperature(OneWire*, uint8_t).

Alimentazione del DS18B20 (normale/parassita)

Il DS18B20 può essere alimentato da una fonte esterna sul pin VDD oppure può operare in modalità “energia parassita”, che consente al DS18B20 di funzionare senza un’alimentazione esterna locale (collegando il VDD a GND). Il DS18B20 “ruba” energia dal bus 1-Wire tramite il pin DQ quando il bus è alto. La carica prelevata alimenta il DS18B20 mentre il bus è alto, e parte di essa viene immagazzinata nel condensatore di alimentazione parassita (CPP) per fornire energia quando il bus è basso.

ESP32 con ds18b20 in modalità parassita: schema

Ma quando il DS18B20 esegue conversioni di temperatura o copia i dati dalla memoria scratchpad all’EEPROM, la corrente operativa può essere alta fino a 1,5mA. Questa corrente può causare una caduta di tensione inaccettabile attraverso il debole resistore pull-up 1-Wire ed essere superiore a quella che il CPP può fornire.

Pull-up forte per la modalità parassita

Per garantire che il DS18B20 disponga di una fornitura di corrente sufficiente, è necessario fornire un pull-up forte sul bus 1-Wire ogni volta che si verificano conversioni di temperatura o si copiano dati dallo scratchpad all’EEPROM.
Questo può essere ottenuto utilizzando un MOSFET per collegare direttamente il bus al rail.

ESP32: schema di cablaggio del ds18b20 in modalità parassita con pull-up forte

Il bus 1-Wire deve essere commutato sul pull-up forte entro 10µs (massimo) dopo le conversioni di temperatura, e deve essere mantenuto alto dal pull-up per tutta la durata della conversione o del trasferimento dei dati. Nessuna altra attività può aver luogo sul bus 1-Wire mentre il pull-up è abilitato.

Il DS18B20 può anche essere alimentato con il metodo convenzionale di collegare una fonte di alimentazione esterna al pin VDD, come mostrato. Il vantaggio di questo metodo è che il pull-up MOSFET non è necessario, e il bus 1-Wire è libero di trasportare altri dati durante il tempo di conversione della temperatura.

L’uso dell’energia parassita non è raccomandato per temperature superiori a +100°C poiché il DS18B20 potrebbe non essere in grado di mantenere le comunicazioni a causa delle correnti di dispersione più elevate che possono verificarsi a tali temperature.

Codice

Ecco alcuni esempi per comprendere meglio.

Per esp8266, devi solo cambiare il pin da 22 a D2 o direttamente a 4.

Utilizzo della libreria per gestire un pull-up forte

Ecco un esempio di codice per ESP32 che utilizza un pull-up forte per leggere in serie una lista di ds18b20:

#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged into port 2 on the Arduino, while external pullup P-MOSFET gate into port 3
#define ONE_WIRE_BUS    22
#define ONE_WIRE_PULLUP 21

// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature. 
DallasTemperature sensors(&oneWire, ONE_WIRE_PULLUP);

void setup(void)
{
  // start serial port
  Serial.begin(9600);
  Serial.println("Dallas Temperature IC Control Library Demo");

  // Start up the library
  sensors.begin();
}

void loop(void)
{ 
  // call sensors.requestTemperatures() to issue a global temperature 
  // request to all devices on the bus
  Serial.print("Requesting temperatures...");
  sensors.requestTemperatures(); // Send the command to get temperatures
  Serial.println("DONE");
  
 for(int i=0;i<sensors.getDeviceCount();i++) {
   Serial.println("Temperature for Device "+String(i)+" is: " + String(sensors.getTempCByIndex(i)));
 } 
}

Nel codice evidenziato puoi vedere come passare il pin per gestire il MOSFET, utile quando il cavo è molto lungo.

Utilizzo dell’allarme

ESP8266 nodemcu: multipli sensori di temperatura ds18b20

Una caratteristica interessante è la gestione degli allarmi. Questa funzionalità è piuttosto semplice: puoi impostare un valore massimo e uno minimo e, in caso di superamento, una funzione restituisce true o viene eseguito un callback.

Gestione di un allarme su un singolo ds18b20

Lo sketch inizializza il sensore e imposta due soglie di allarme per la temperatura, una per l’allarme di alta temperatura e una per quello di bassa temperatura. Lo sketch richiede continuamente le letture di temperatura dal sensore e verifica la presenza di condizioni di allarme. Se viene rilevata una condizione di allarme, lo sketch mostra un messaggio di avviso contenente l’indirizzo del dispositivo e la lettura della temperatura.

/**
 * From the original example of the library.
 *
 * Here a manual management of alarm without an handler.
 *
 * by Renzo Mischianti <www.mischianti.org>
 *
 * https://mischianti.org
 */

#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged into port 22
#define ONE_WIRE_BUS 22

// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);

// arrays to hold device addresses
DeviceAddress insideThermometer;

void setup(void)
{
  // start serial port
  Serial.begin(115200);
  Serial.println("Dallas Temperature IC Control Library Demo");

  // Start up the library
  sensors.begin();

  // locate devices on the bus
  Serial.print("Found ");
  Serial.print(sensors.getDeviceCount(), DEC);
  Serial.println(" devices.");

  // search for devices on the bus and assign based on an index.
  if (!sensors.getAddress(insideThermometer, 0)) Serial.println("Unable to find address for Device 0");

  // show the addresses we found on the bus
  Serial.print("Device 0 Address: ");
  printAddress(insideThermometer);
  Serial.println();

  Serial.print("Device 0 Alarms: ");
  printAlarms(insideThermometer);
  Serial.println();

  Serial.println("Setting alarm temps...");

  // alarm when temp is higher than 22C
  sensors.setHighAlarmTemp(insideThermometer, 22);

  // alarm when temp is lower than 20C
  sensors.setLowAlarmTemp(insideThermometer, 20);

  Serial.print("New Device 0 Alarms: ");
  printAlarms(insideThermometer);
  Serial.println();

}

// function to print a device address
void printAddress(DeviceAddress deviceAddress)
{
  for (uint8_t i = 0; i < 8; i++)
  {
    if (deviceAddress[i] < 16) Serial.print("0");
    Serial.print(deviceAddress[i], HEX);
  }
}

// function to print the temperature for a device
void printTemperature(DeviceAddress deviceAddress)
{
  float tempC = sensors.getTempC(deviceAddress);
  Serial.print("Temp C: ");
  Serial.print(tempC);
  Serial.print(" Temp F: ");
  Serial.print(DallasTemperature::toFahrenheit(tempC));
}

void printAlarms(uint8_t deviceAddress[])
{
  char temp;
  temp = sensors.getHighAlarmTemp(deviceAddress);
  Serial.print("High Alarm: ");
  Serial.print(temp, DEC);
  Serial.print("C/");
  Serial.print(DallasTemperature::toFahrenheit(temp));
  Serial.print("F | Low Alarm: ");
  temp = sensors.getLowAlarmTemp(deviceAddress);
  Serial.print(temp, DEC);
  Serial.print("C/");
  Serial.print(DallasTemperature::toFahrenheit(temp));
  Serial.print("F");
}

// main function to print information about a device
void printData(DeviceAddress deviceAddress)
{
  Serial.print("Device Address: ");
  printAddress(deviceAddress);
  Serial.print(" ");
  printTemperature(deviceAddress);
  Serial.println();
}

void checkAlarm(DeviceAddress deviceAddress)
{
  if (sensors.hasAlarm(deviceAddress))
  {
    Serial.print("ALARM: ");
    printData(deviceAddress);
  }
}

void loop(void)
{
  // call sensors.requestTemperatures() to issue a global temperature
  // request to all devices on the bus
  Serial.print("Requesting temperatures...");
  sensors.requestTemperatures();
  Serial.print("DONE --> ");
  printData(insideThermometer);

  // Method 1:
  // check each address individually for an alarm condition
  checkAlarm(insideThermometer);
/*
  // Alternate method:
  // Search the bus and iterate through addresses of devices with alarms

  // space for the alarm device's address
  DeviceAddress alarmAddr;

  Serial.println("Searching for alarms...");

  // resetAlarmSearch() must be called before calling alarmSearch()
  sensors.resetAlarmSearch();

  // alarmSearch() returns 0 when there are no devices with alarms
  while (sensors.alarmSearch(alarmAddr))
  {
    Serial.print("ALARM: ");
    printData(alarmAddr);
  }
*/

  delay(2000);
}


Ecco il risultato.

Dallas Temperature IC Control Library Demo
Found 5 devices.
Device 0 Address: 28FF640E6C63D015
Device 0 Alarms: High Alarm: 22C/71.60F | Low Alarm: 21C/69.80F
Setting alarm temps...
New Device 0 Alarms: High Alarm: 22C/71.60F | Low Alarm: 20C/68.00F
Requesting temperatures...DONE --> Device Address: 28FF640E6C63D015 Temp C: 21.12 Temp F: 70.03
Requesting temperatures...DONE --> Device Address: 28FF640E6C63D015 Temp C: 21.12 Temp F: 70.03
Requesting temperatures...DONE --> Device Address: 28FF640E6C63D015 Temp C: 21.19 Temp F: 70.14
Requesting temperatures...DONE --> Device Address: 28FF640E6C63D015 Temp C: 21.12 Temp F: 70.03
Requesting temperatures...DONE --> Device Address: 28FF640E6C63D015 Temp C: 21.12 Temp F: 70.03
Requesting temperatures...DONE --> Device Address: 28FF640E6C63D015 Temp C: 21.19 Temp F: 70.14
Requesting temperatures...DONE --> Device Address: 28FF640E6C63D015 Temp C: 21.12 Temp F: 70.03
Requesting temperatures...DONE --> Device Address: 28FF640E6C63D015 Temp C: 21.19 Temp F: 70.14
Requesting temperatures...DONE --> Device Address: 28FF640E6C63D015 Temp C: 21.19 Temp F: 70.14
Requesting temperatures...DONE --> Device Address: 28FF640E6C63D015 Temp C: 22.37 Temp F: 72.28
ALARM: Device Address: 28FF640E6C63D015 Temp C: 22.37 Temp F: 72.28
Requesting temperatures...DONE --> Device Address: 28FF640E6C63D015 Temp C: 22.62 Temp F: 72.72
ALARM: Device Address: 28FF640E6C63D015 Temp C: 22.62 Temp F: 72.72
Requesting temperatures...DONE --> Device Address: 28FF640E6C63D015 Temp C: 22.37 Temp F: 72.28
ALARM: Device Address: 28FF640E6C63D015 Temp C: 22.37 Temp F: 72.28
Requesting temperatures...DONE --> Device Address: 28FF640E6C63D015 Temp C: 22.19 Temp F: 71.94
ALARM: Device Address: 28FF640E6C63D015 Temp C: 22.19 Temp F: 71.94
Requesting temperatures...DONE --> Device Address: 28FF640E6C63D015 Temp C: 21.87 Temp F: 71.37
Requesting temperatures...DONE --> Device Address: 28FF640E6C63D015 Temp C: 21.75 Temp F: 71.15
Requesting temperatures...DONE --> Device Address: 28FF640E6C63D015 Temp C: 21.62 Temp F: 70.92

Gestione di un unico handler di allarme per tutti i sensori

ESP32 DOIT DEV KIT v1: multipli sensori di temperatura ds18b20

Ecco un esempio con 2 sensori e le stesse impostazioni di allarme. Quando l’allarme viene attivato, l’handler viene chiamato per ogni sensore.

/**
 * Here 2 ds18b20 with the same alarm settings, and an handler for the alarm.
 *
 * When the Alarm is raised, the handler is called for every sensor in alarm state.
 *
 * by Renzo Mischianti <www.mischianti.org>
 *
 * https://mischianti.org
 *
 */

#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged into port 22
#define ONE_WIRE_BUS 22

// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);

// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);

// arrays to hold device addresses
DeviceAddress thermometer1, thermometer2;

// function that will be called when an alarm condition exists during DallasTemperatures::processAlarms();
void newAlarmHandler(const uint8_t* deviceAddress)
{
  Serial.println("Alarm Handler Start");
  printAlarmInfo(deviceAddress);
  printTemp(deviceAddress);
  Serial.println();
  Serial.println("Alarm Handler Finish");
}

void printCurrentTemp(DeviceAddress deviceAddress)
{
  printAddress(deviceAddress);
  printTemp(deviceAddress);
}

void printAddress(const DeviceAddress deviceAddress)
{
  Serial.print("Address: ");
  for (uint8_t i = 0; i < 8; i++)
  {
    if (deviceAddress[i] < 16) Serial.print("0");
    Serial.print(deviceAddress[i], HEX);
  }
  Serial.print(" ");
}

void printTemp(const DeviceAddress deviceAddress)
{
  float tempC = sensors.getTempC(deviceAddress);
  if (tempC != DEVICE_DISCONNECTED_C)
  {
    Serial.print("Current Temp C: ");
    Serial.print(tempC);
  }
  else Serial.print("DEVICE DISCONNECTED");
  Serial.print(" ");
}

void printAlarmInfo(const DeviceAddress deviceAddress)
{
  char temp;
  printAddress(deviceAddress);
  temp = sensors.getHighAlarmTemp(deviceAddress);
  Serial.print("High Alarm: ");
  Serial.print(temp, DEC);
  Serial.print("C");
  Serial.print(" Low Alarm: ");
  temp = sensors.getLowAlarmTemp(deviceAddress);
  Serial.print(temp, DEC);
  Serial.print("C");
  Serial.print(" ");
}

void setup(void)
{
  // start serial port
  Serial.begin(115200);
  Serial.println("Dallas Temperature IC Control Library Demo");

  // Start up the library
  sensors.begin();

  // locate devices on the bus
  Serial.print("Found ");
  Serial.print(sensors.getDeviceCount(), DEC);
  Serial.println(" devices.");

  // search for devices on the bus and assign based on an index
  if (!sensors.getAddress(thermometer1, 0)) Serial.println("Unable to find address for Device 0");
  // search for devices on the bus and assign based on an index
  if (!sensors.getAddress(thermometer2, 1)) Serial.println("Unable to find address for Device 1");

  Serial.print("Device thermometer1 ");
  printAlarmInfo(thermometer1);
  Serial.println();

  // set alarm ranges
  Serial.println("Setting alarm temps...");
  sensors.setHighAlarmTemp(thermometer1, 22);
  sensors.setLowAlarmTemp(thermometer1, 20);

  Serial.print("New thermometer1 ");
  printAlarmInfo(thermometer1);
  Serial.println();

  Serial.print("Device thermometer2 ");
  printAlarmInfo(thermometer2);
  Serial.println();

  // set alarm ranges
  Serial.println("Setting alarm temps...");
  sensors.setHighAlarmTemp(thermometer2, 22);
  sensors.setLowAlarmTemp(thermometer2, 20);

  Serial.print("New thermometer2 ");
  printAlarmInfo(thermometer2);
  Serial.println();

  // attach alarm handler
  sensors.setAlarmHandler(&newAlarmHandler);

}

void loop(void)
{
  // ask the devices to measure the temperature
  sensors.requestTemperatures();

  // if an alarm condition exists as a result of the most recent
  // requestTemperatures() request, it exists until the next time
  // requestTemperatures() is called AND there isn't an alarm condition
  // on the device
  if (sensors.hasAlarm())
  {
    Serial.println("Oh noes!  There is at least one alarm on the bus.");
  }

  // call alarm handler function defined by sensors.setAlarmHandler
  // for each device reporting an alarm
  sensors.processAlarms();

  if (!sensors.hasAlarm())
  {
    // just print out the current temperature
	    printCurrentTemp(thermometer1);
	    Serial.print(" - ");
	    printCurrentTemp(thermometer2);
	    Serial.println();
  }

  delay(1000);
}

Per impostare l’handler, esiste una funzione specifica:

  // attach alarm handler
  sensors.setAlarmHandler(&newAlarmHandler);

Questo handler è per tutti i sensori, ed è processato con questa funzione:

  // call alarm handler function defined by sensors.setAlarmHandler
  // for each device reporting an alarm
  sensors.processAlarms();

In questo caso, i 2 sensori non si attivano contemporaneamente: prima solo il termometro con indirizzo 28FF640E6C6F7A89, poi entrambi insieme.

Dallas Temperature IC Control Library Demo
Found 5 devices.
Device thermometer1 Address: 28FF640E6C63D015 High Alarm: 22C Low Alarm: 20C 
Setting alarm temps...
New thermometer1 Address: 28FF640E6C63D015 High Alarm: 22C Low Alarm: 20C 
Device thermometer2 Address: 28FF640E6C6F7A89 High Alarm: 22C Low Alarm: 20C 
Setting alarm temps...
New thermometer2 Address: 28FF640E6C6F7A89 High Alarm: 22C Low Alarm: 20C 
Address: 28FF640E6C63D015 Current Temp C: 20.75  - Address: 28FF640E6C6F7A89 Current Temp C: 20.69 
Address: 28FF640E6C63D015 Current Temp C: 20.75  - Address: 28FF640E6C6F7A89 Current Temp C: 20.69 
Address: 28FF640E6C63D015 Current Temp C: 20.75  - Address: 28FF640E6C6F7A89 Current Temp C: 20.69 
Address: 28FF640E6C63D015 Current Temp C: 20.75  - Address: 28FF640E6C6F7A89 Current Temp C: 20.69 
Address: 28FF640E6C63D015 Current Temp C: 20.75  - Address: 28FF640E6C6F7A89 Current Temp C: 20.69 
Address: 28FF640E6C63D015 Current Temp C: 20.75  - Address: 28FF640E6C6F7A89 Current Temp C: 20.69 
Address: 28FF640E6C63D015 Current Temp C: 20.75  - Address: 28FF640E6C6F7A89 Current Temp C: 20.69 
Address: 28FF640E6C63D015 Current Temp C: 20.75  - Address: 28FF640E6C6F7A89 Current Temp C: 20.69 
Address: 28FF640E6C63D015 Current Temp C: 20.75  - Address: 28FF640E6C6F7A89 Current Temp C: 20.69 
Address: 28FF640E6C63D015 Current Temp C: 20.75  - Address: 28FF640E6C6F7A89 Current Temp C: 20.69 
Address: 28FF640E6C63D015 Current Temp C: 20.75  - Address: 28FF640E6C6F7A89 Current Temp C: 20.69 
Address: 28FF640E6C63D015 Current Temp C: 20.75  - Address: 28FF640E6C6F7A89 Current Temp C: 20.69 
Address: 28FF640E6C63D015 Current Temp C: 21.06  - Address: 28FF640E6C6F7A89 Current Temp C: 21.50 
Oh noes!  There is at least one alarm on the bus.
Alarm Handler Start
Address: 28FF640E6C6F7A89 High Alarm: 22C Low Alarm: 20C Current Temp C: 22.62 
Alarm Handler Finish
Oh noes!  There is at least one alarm on the bus.
Alarm Handler Start
Address: 28FF640E6C63D015 High Alarm: 22C Low Alarm: 20C Current Temp C: 22.56 
Alarm Handler Finish
Alarm Handler Start
Address: 28FF640E6C6F7A89 High Alarm: 22C Low Alarm: 20C Current Temp C: 23.44 
Alarm Handler Finish
Oh noes!  There is at least one alarm on the bus.
Alarm Handler Start
Address: 28FF640E6C63D015 High Alarm: 22C Low Alarm: 20C Current Temp C: 23.12 
Alarm Handler Finish
Alarm Handler Start
Address: 28FF640E6C6F7A89 High Alarm: 22C Low Alarm: 20C Current Temp C: 23.62 
Alarm Handler Finish
Oh noes!  There is at least one alarm on the bus.
Alarm Handler Start
Address: 28FF640E6C63D015 High Alarm: 22C Low Alarm: 20C Current Temp C: 22.94 
Alarm Handler Finish
Alarm Handler Start
Address: 28FF640E6C6F7A89 High Alarm: 22C Low Alarm: 20C Current Temp C: 23.31 
Alarm Handler Finish
Oh noes!  There is at least one alarm on the bus.
Alarm Handler Start
Address: 28FF640E6C63D015 High Alarm: 22C Low Alarm: 20C Current Temp C: 22.75 
Alarm Handler Finish
Alarm Handler Start
Address: 28FF640E6C6F7A89 High Alarm: 22C Low Alarm: 20C Current Temp C: 23.06 
Alarm Handler Finish
Oh noes!  There is at least one alarm on the bus.
Alarm Handler Start
Address: 28FF640E6C63D015 High Alarm: 22C Low Alarm: 20C Current Temp C: 22.56 
Alarm Handler Finish
Alarm Handler Start
Address: 28FF640E6C6F7A89 High Alarm: 22C Low Alarm: 20C Current Temp C: 22.81 
Alarm Handler Finish

Grazie

  1. ESP32: pinout, specs and Arduino IDE configuration
  2. ESP32: integrated SPIFFS Filesystem
  3. ESP32: manage multiple Serial and logging
  4. ESP32 practical power saving
    1. ESP32 practical power saving: manage WiFi and CPU
    2. ESP32 practical power saving: modem and light sleep
    3. ESP32 practical power saving: deep sleep and hibernation
    4. ESP32 practical power saving: preserve data, timer and touch wake up
    5. ESP32 practical power saving: external and ULP wake up
    6. ESP32 practical power saving: UART and GPIO wake up
  5. ESP32: integrated LittleFS FileSystem
  6. ESP32: integrated FFat (Fat/exFAT) FileSystem
  7. ESP32-wroom-32
    1. ESP32-wroom-32: flash, pinout, specs and IDE configuration
  8. ESP32-CAM
    1. ESP32-CAM: pinout, specs and Arduino IDE configuration
    2. ESP32-CAM: upgrade CamerWebServer with flash features
  9. ESP32: use ethernet w5500 with plain (HTTP) and SSL (HTTPS)
  10. ESP32: use ethernet enc28j60 with plain (HTTP) and SSL (HTTPS)
  11. How to use SD card with esp32
  12. esp32 and esp8266: FAT filesystem on external SPI flash memory
  1. Firmware and OTA update management
    1. Firmware management
      1. ESP32: flash compiled firmware (.bin)
      2. ESP32: flash compiled firmware and filesystem (.bin) with GUI tools
    2. OTA update with Arduino IDE
      1. ESP32 OTA update with Arduino IDE: filesystem, firmware, and password
    3. OTA update with Web Browser
      1. ESP32 OTA update with Web Browser: firmware, filesystem, and authentication
      2. ESP32 OTA update with Web Browser: upload in HTTPS (SSL/TLS) with self-signed certificate
      3. ESP32 OTA update with Web Browser: custom web interface
    4. Self OTA uptate from HTTP server
      1. ESP32 self OTA update firmware from the server
      2. ESP32 self OTA update firmware from the server with version check
      3. ESP32 self-OTA update in HTTPS (SSL/TLS) with trusted self-signed certificate
    5. Non-standard Firmware update
      1. ESP32 firmware and filesystem update from SD card
      2. ESP32 firmware and filesystem update with FTP client
  1. Integrating LAN8720 with ESP32 for Ethernet Connectivity with plain (HTTP) and SSL (HTTPS)
  2. Connecting the EByte E70 to ESP32 c3/s3 devices and a simple sketch example
  3. ESP32-C3: pinout, specs and Arduino IDE configuration
  4. Integrating W5500 with ESP32 Using Core 3: Native Ethernet Protocol Support with SSL and Other Features
  5. Integrating LAN8720 with ESP32 Using Core 3: Native Ethernet Protocol Support with SSL and Other Features
  6. Dallas ds18b20:

Spread the love
Exit mobile version