Arduino

Digitale temperatuursensor DS18B20

Laatst bijgewerkt: 21/08/2020

Sensor DS18B20

De DS18B20 is een digitale temperatuursensor die het 1 draads protocol gebruikt om te communiceren, dit protocol heeft slechts één data pin nodig om te communiceren en maakt het mogelijk om meer dan één sensor op dezelfde bus aan te sluiten.

De DS18B20 sensor is vervaardigd door Maxim Integrated, het fabriekspakket is van het type TO-92 vergelijkbaar met dat van kleine transistors. De meest gebruikte commerciële presentatie voor gemak en robuustheid is de sensor in een roestvrijstalen buis die bestand is tegen water, waarmee we deze zelfstudie uitvoeren.

Met deze sensor kunnen we de temperatuur meten van -55 ° C tot 125 ° C en met een programmeerbare resolutie van 9 bits tot 12 bits.

Elke sensor heeft een uniek fabrieksadres van 64 bits, dit adres dient om het apparaat te identificeren waarmee het communiceert, omdat in een 1-draads bus er meer dan één apparaat kan zijn.

De sensor heeft twee voedingsmethoden:

Vermogen door de data-pin:

Op deze manier verkrijgt de sensor intern energie van de datapen wanneer deze in een hoge staat is en slaat lading op in een condensator voor wanneer de datalijn zich in een lage toestand bevindt, deze manier om energie te verkrijgen wordt "parasiet" genoemd Power "en het wordt gebruikt wanneer de sensor over grote afstanden moet worden aangesloten of waar de ruimte beperkt is, omdat op deze manier de VDD-lijn niet nodig is. Het diagram voor uw verbinding zou als volgt moeten zijn:

Merk op dat de pin GND en VDD beide met GND zijn verbonden, dit is essentieel om de Parasite Power te activeren. De MOSFET in het beeld is nodig voor temperatuurconversies of het kopiëren van gegevens uit het circuitgeheugen van de EEPROM, bij deze bewerkingen neemt de werkstroom toe en als er alleen stroom wordt geleverd via de weerstand, kunnen deze spanningsdalingen veroorzaken in de interne condensator.

Vermogen met behulp van een externe bron:

Op deze manier wordt de sensor door de VDD-pin gevoerd, op deze manier is de spanning stabiel en onafhankelijk van het 1 draads busverkeer.

Het aansluitschema is als volgt:

Deze vorm van voeding wordt het meest aanbevolen en wordt gebruikt in deze zelfstudie.

Bibliotheken voor de DS18B20 in Arduino

Om de DS18B20 in Arduino te laten werken hebben we twee bibliotheken nodig:

* OneWire-bibliotheek, download: https://github.com/PaulStoffregen/OneWire

In deze bibliotheek is het volledige 1-draads busprotocol geïmplementeerd. En het kan worden gebruikt voor zowel de DS18B20 als andere 1-draads apparaten, voor meer informatie over de bibliotheek: http://www.pjrc.com/teensy/td_libs_OneWire.html

* Bibliotheek DallasTemperature, download: https://github.com/milesburton/Arduino-Temperature-Control-Library

In deze bibliotheek zijn de nodige functies geïmplementeerd om de metingen of configuraties van de DS18B20 uit te kunnen voeren, voor meer informatie over de bibliotheek, kijk op: http://www.milesburton.com/Dallas_Temperature_Control_Library

Aansluitingen van de DS18B20 met Arduino:

Merk op dat het noodzakelijk is om een pull-up-weerstand van 4,7K te verhogen en een breadboard te gebruiken om de verbinding te vergemakkelijken.

Ex.1: Uitvoeren van temperatuurmetingen met de DS18B20

Na het installeren van de bibliotheken en het maken van de vorige verbinding kunnen we de temperatuurmetingen uitvoeren, daarvoor gebruiken we de volgende schets:

#include <OneWire.h>
#include <DallasTemperature.h>
OneWire ourWire(2);  //Pin 2 is opgezet als een OneWire-bus
DallasTemperature sensors(&ourWire); // aanmaken van een variabele of een object voor onze sensor
void setup(){
 delay(1000);
 Serial.begin(9600);
 sensors.begin();   //De sensor start
}
void loop() {
 sensors.requestTemperatures();   //Het commando wordt verzonden om de temperatuur te lezen
 float temp= sensors.getTempCByIndex(0); //De temperatuur wordt verkregen in ° C
 Serial.print("Temperatuur= ");
 Serial.print(temp);
 Serial.println(" C");
 delay(100);
}

Omdat wordt gemeten dat de temperatuur eenvoudig is, zijn slechts twee regels in de lege loop () nodig om deze taak uit te voeren.

Het resultaat is het volgende:

Verschillende temperatuursensoren aansluiten:
We hebben twee opties of methoden die we kunnen gebruiken wanneer we meer dan één temperatuursensor moeten lezen.

De eerste methode is om elke sensor met een andere pin van de Arduino te hanteren. Op deze manier hebben we 3 sensoren, we zullen 3 digitale pinnen van de Arduino moeten gebruiken.

Een andere manier is om dezelfde pen te gebruiken voor alle sensoren, met andere woorden alle sensoren zijn verbonden met dezelfde 1-draads bus en zoals elke bus heeft elk element of apparaat een identificatie of adres. In het geval van de DS18B20 moeten we uw adres weten dat uniek is en in de fabriek is ingesteld.

Ex.2: Verschillende DS18B20 gebruiken in verschillende pinnen van de Arduino:

Voor dit geval zijn de verbindingen de volgende:

Elke sensor werkt met een andere pen en heeft zijn eigen Pull-Up-weerstand van 4,7K.

De code om de metingen uit te voeren is als volgt:

#include <OneWire.h>
#include <DallasTemperature.h>
OneWire ourWire1(2);  //Pin 2 is opgezet als een OneWire-bus
OneWire ourWire2(3);  //Pin 3 is opgezet als een OneWire-bus
DallasTemperature sensors1(&ourWire1); //aanmaken van een variabele of een object voor onze sensor 1
DallasTemperature sensors2(&ourWire2); //aanmaken van een variabele of een object voor onze sensor 2

void setup(){
 delay(1000);
 Serial.begin(9600);
 sensors1.begin();   //De sensor 1 start
 sensors2.begin();   //De sensor 2 start
}

void loop(){
 sensors1.requestTemperatures();   //Het commando wordt verzonden om de temperatuur te lezen
 float temp1= sensors1.getTempCByIndex(0); //De temperatuur in ° C van de sensor 1 wordt verkregen
 sensors2.requestTemperatures();   //Het commando wordt verzonden om de temperatuur te lezen
 float temp2= sensors2.getTempCByIndex(0); //De temperatuur in ° C van de sensor 2 wordt verkregen
 Serial.print("Temperatuur 1 = ");
 Serial.print(temp1);
 Serial.print(" C");
 Serial.print(" Temperatuur 2 = ");
 Serial.print(temp2);
 Serial.println(" C");
 delay(100);
}

Deze manier om twee of meer sensoren aan te sluiten is gemakkelijk te begrijpen en te implementeren en is handig wanneer er weinig sensoren zijn of we eenvoudig pinnen beschikbaar hebben om meer DS18B20 aan te sluiten zoals in een Arduino Mega.

Ex.3: Verschillende DS18B20 gebruiken met een enkele pin van de Arduino:

In dit geval verbinden we alle sensoren met dezelfde 1-draads bus.

Indien nodig, is het mogelijk om meer sensoren op dezelfde gegevenspin aan te sluiten.

Het verschil hier is dat we als bus het adres van elke sensor moeten achterhalen om het te identificeren.

De volgende schets wordt alleen gebruikt om het adres te verkrijgen van de apparaten die op de 1-draads bus zijn aangesloten:

#include <OneWire.h>
OneWire ourWire(2); //Pin  2 is opgezet als een OneWire-bus OneWire
void setup(void) {
 Serial.begin(9600);
}
void loop(void) {
 byte addr[8];
 Serial.println("Routebeschrijving opvragen:");
 while (ourWire.search(addr)){  
    Serial.print("Address = ");
    for(int i = 0; i < 8; i++) {
      Serial.print(" 0x");
      Serial.print(addr[i], HEX);
    }
    Serial.println();
 }
 Serial.println();
 ourWire.reset_search();
 delay(2000);
}

De vorige code helpt ons om de adressen van de sensoren te verkrijgen, in ons geval hebben we de adressen van de drie sensoren die we hebben aangesloten verkregen, maar ze kunnen de vorige code voor elke sensor afzonderlijk uitvoeren om precies de richting van hun sensor te kennen.

Zodra het adres is verkregen, kunnen we de sensor meting identificeren die we willen meten.

Voor het maken van de metingen gebruiken we de volgende schets:

#include <OneWire.h>
#include <DallasTemperature.h>
OneWire ourWire(2); //Pin  2 is opgezet als een OneWire bus voor DallasTemperature sensors
DeviceAddress address1 = {0x28, 0xFF, 0xCA, 0x4A, 0x5, 0x16, 0x3, 0xBD};//adres van sensor 1
DeviceAddress address2 = {0x28, 0xFF, 0x89, 0x3A, 0x1, 0x16, 0x4, 0xAF};//adres van sensor 2
DeviceAddress address3 = {0x28, 0xFF, 0x23, 0x19, 0x1, 0x16, 0x4, 0xD9};//adres van sensor 3
void setup(){
 delay(1000);
 Serial.begin(9600);
 sensors.begin(); //De sensor  start
}
void loop() {
 sensors.requestTemperatures();   //stuur het commando om de temperaturen te krijgen
 float temp1= sensors.getTempC(address1);//De temperatuur in ° C van sensor 1 wordt verkregen
 float temp2= sensors.getTempC(address2);//De temperatuur in ° C van sensor 2 wordt verkregen
 float temp3= sensors.getTempC(address3);//De temperatuur in ° C van sensor 3 wordt verkregen
 Serial.print("Temperatuur 1 = ");
 Serial.print(temp1);
 Serial.print(" C");
 Serial.print("   Temperatuur  2 = ");
 Serial.print(temp2);
 Serial.print(" C");
 Serial.print("    Temperatuur 3 = ");
 Serial.print(temp3);
 Serial.println(" C");
 delay(100);
 delay(100);
}

Er moet rekening worden gehouden met het feit dat de adressen in de schets moeten worden vervangen door de adressen die overeenkomen met de beschikbare sensoren.
Hier tonen we onze resultaten:

De waargenomen temperaturen zijn vergelijkbaar omdat de sensoren zich in dezelfde omgeving bevonden:

DS18B20 Resolution

de DS18B20 heeft vier selecteerbare resoluties die variëren van 9 tot 12. Hoewel het misschien leuk lijkt om een zeer gedetailleerde ‘precieze’ meting te hebben, is er een afweging. In het bijzonder, hoe hoger de resolutie, hoe meer tijd het zal kosten om de meting uit te voeren. Zie onderstaande tabel.

Resolution Nauwkeurigheid Tijd
9 Bit 0.5 93.75 mSec
10 Bit 0.25 187.5 mSec
11 Bit 0.125 375 mSec
12 Bit 0.0625 750 mSec
sensors.setResolution(Address, 9); // 9 bits resolutie voor een bepaalde sensor
sensors.getResolution(Address)     // opvragen van de resolutie
sensors.setResolution(9);          // 9 bits resolutie voor alle sensors
sensors.getResolution(Address1)    // opvragen van de resolutie voor elke sensor afzonderlijk
sensors.getResolution(Address2)

Normaal gesproken wordt de resolutie geconfigureerd in de setup () na initialisatie van de sensoren. Hoe lager de resolutie, hoe korter de leestijd.