OneWire ds(2); void setup() ( Serial.begin(9600); ) void loop() ( byte i; byte data; byte addr; float celsius; // Suche nach Sensoradresse if (!ds.search(addr)) ( ds.reset_search ( ); return; ds.select(addr); // Befehl zum Auslesen der gemessenen Temperatur // die Temperaturwerte aus dem internen Speicher des Sensors lesen für (i = 0; i

DS18B20 ist ein digitaler Temperatursensor. Der Sensor ist sehr einfach zu bedienen.

Erstens ist es digital und zweitens hat es nur einen Kontakt, von dem wir ein nützliches Signal erhalten. Das heißt, Sie können eine große Anzahl dieser Sensoren gleichzeitig an ein Arduino anschließen. Es wird mehr als genug Pins geben. Darüber hinaus können Sie sogar mehrere Sensoren an einen Pin des Arduino anschließen! Aber das Wichtigste zuerst.

Der DS18B20 ist in verschiedenen Formfaktoren erhältlich. Die Wahl liegt also bei Ihnen. Es stehen drei Optionen zur Verfügung: 8-Pin SO (150 mil), 8-Pin µSOP und 3-Pin TO-92. Ein Blick auf eBay oder Aliexpress zeigt, dass die Chinesen eine Version des TO-92 in einem wasserdichten Gehäuse anbieten. Das heißt, Sie können ein solches Wunder bedenkenlos in Wasser tauchen, im Regen verwenden usw. usw. Diese Sensoren werden mit drei Ausgangspins hergestellt (schwarz – GND, rot – Vdd und weiß – Daten).

Die verschiedenen Formfaktoren der DS18B20-Sensoren sind in der folgenden Abbildung dargestellt.

Modell DS18B20 im wasserdichten Gehäuse:

DS18B20 ist einfach zu bedienen. Sie können es über den Datenkontakt mit Strom versorgen (in diesem Fall nutzen Sie nur zwei der drei Kontakte für den Anschluss!). Der Sensor arbeitet in einem Spannungsbereich von 3,0 V bis 5,5 V und misst Temperaturen von -55 °C bis +125 °C (-67 °F bis +257 °F) mit einer Genauigkeit von ±0,5 °C (-10 °C). ) bis +85°C).

Ein weiteres cooles Feature: Sie können bis zu 127 Sensoren parallel anschließen! und lesen Sie die Temperaturwerte von jedem einzeln ab. Es ist nicht ganz klar, bei welchem ​​Projekt dies erforderlich sein könnte, aber Sie können zwei Sensoren anschließen und die Temperatur im Kühl- und Gefrierschrank steuern. Gleichzeitig bleiben ein paar Pins auf dem Arduino frei... Im Allgemeinen ist das eine nette Funktion.

Was Sie brauchen, um die Temperatur mit Arduino und DS18B20 zu steuern

Software

• Natürlich benötigen Sie die Arduino IDE;
• Die OneWire-Bibliothek, die die Arbeit mit Arduino und dem DS18B20-Sensor erheblich erleichtert;
• Skizzieren...

Hochladen der Skizze auf Arduino

Die folgende Skizze befindet sich in der OneWire-Bibliothek in der Kategorie „Beispiele“. Gehen Sie zu „Datei“ – „Beispiele“ – „OneWire“ und wählen Sie das Beispiel „DS18x20_Temperature“ aus. Der Programmcode ist unten dargestellt.

In diesem Beispiel wird die OneWire-Bibliothek verwendet, um Daten von allen angeschlossenen DS28B20-Temperatursensoren zu sammeln (wie Sie mehrere Sensoren anschließen, wird am Ende des Artikels beschrieben) und sie im seriellen Überwachungsfenster der Arduino IDE anzuzeigen.

Im Serial Monitor-Fenster sehen Sie etwa Folgendes:

ROM = 28 88 84 82 5 0 0 6A

Keine Adressen mehr.

ROM = 28 88 84 82 5 0 0 6A

Daten = 1 56 1 4B 46 7F FF A 10 D1 CRC=D1

Temperatur = 21,37 Celsius, 70,47 Fahrenheit

Keine Adressen mehr.

ROM = 28 88 84 82 5 0 0 6A

Daten = 1 56 1 4B 46 7F FF A 10 D1 CRC=D1

Temperatur = 21,37 Celsius, 70,47 Fahrenheit

Keine Adressen mehr.

Stellen Sie sicher, dass Sie die richtigen Pins eingeben!

In Zeile 10 steht „OneWire ds(2);“ Der Pin, an dem der Datenkontakt vom Sensor angeschlossen wird, ist eingestellt.

In diesem Beispiel wird Pin 2 verwendet, aber der Standard-Pin im OneWire-Beispiel ist 10. Sie können diesen auch verwenden.

#include <OneWire.h>

// Beispiel für die Verwendung der OneWire DS18S20, DS18B20, DS1822-Bibliothek

OneWire ds(2); // an Pin 10 (benötigt einen 4,7 kOhm Widerstand)

void setup(void) (

Serial.begin(9600);

Void-Schleife (Void) (

Byte vorhanden = 0;

Float Celsius, Fahrenheit;

if (!ds.search(addr)) (

Serial.println("Keine weiteren Adressen.");

Serial.println();

ds.reset_search();

Serial.print("ROM =");

Serial.write(" ");

Serial.print(addr[i], HEX);

if (OneWire::crc8(addr, 7) != addr) (

Serial.println("CRC ist ungültig!");

Serial.println();

// erstes Byte identifiziert den Chip

Serial.println("Chip = DS18S20"); // oder älterer DS1820

Serial.println("Chip = DS18B20");

Serial.println("Chip = DS1822");

Serial.println("Gerät ist kein Gerät der DS18x20-Familie.");

ds.select(addr);

Verzögerung (1000); // 750 können ausreichen oder auch nicht

// Wir könnten hier ds.depower() verwenden, aber das wird durch Zurücksetzen erledigt

present = ds.reset();

ds.select(addr);

Serial.print(" Data = ");

Serial.print(present, HEX);

Serial.print(" ");

data[i] = ds.read();

Serial.print(data[i], HEX);

Serial.print(" ");

Serial.print(" CRC=");

Serial.print(OneWire::crc8(data, 8), HEX);

Serial.println();

// Wandeln Sie dies in die tatsächliche Temperatur um

// Da das Ergebnis eine 16-Bit-Ganzzahl ist, muss es in gespeichert werden

// Variable mit Datentyp „int16_t“, die immer gleich 16 Bit ist,

// auch wenn wir auf einem 32-Bit-Prozessor kompilieren

int16_t raw = (Daten

if (Daten == 0x10) (

raw = (raw & 0xFFF0) + 12 – Daten;

Byte cfg = (Daten & 0x60);

// für kleine Werte sind kleine Bits nicht definiert, wir setzen sie zurück

if (cfg == 0x00) raw = raw & ~7; // Auflösung 9 Bit, 93,75 ms

sonst if (cfg == 0x20) raw = raw & ~3; // Auflösung 10 Bit, 187,5 ms

sonst if (cfg == 0x40) raw = raw & ~1; // Auflösung 11 Bit, 375 ms

//// Die Standardauflösung beträgt 12 Bit, die Konvertierungszeit beträgt 750 ms

Celsius = (float)raw / 16,0;

Fahrenheit = Celsius * 1,8 + 32,0;

Serial.print(" Temperature = ");

Serial.print(celsius);

Serial.print(" Celsius, ");

Serial.print(fahrenheit);

Serial.println("Fahrenheit");

Wie verbinde ich mehrere DS18B20-Sensoren mit Arduino?

Sie können mehrere digitale Temperatursensoren DS18B20 parallel anschließen. Gleichzeitig ermöglicht Ihnen die OneWire-Bibliothek, Daten von allen Sensoren gleichzeitig auszulesen.

Im Folgenden werden zwei Methoden zum Anschließen von Sensoren beschrieben.

Bei einer großen Anzahl von Sensoren (mehr als 10) ist es notwendig, Widerstände mit geringerem Widerstandswert (z. B. 1,6 KOhm oder sogar weniger) zu verwenden.

Darüber hinaus kann es bei der Parallelschaltung von mehr als 10 Sensoren zu Problemen kommen (Fehler bei der Messwerterfassung). Daher empfiehlt es sich, zwischen dem Datenpin am Arduino und dem Datenpin an jedem Sensor einen zusätzlichen Widerstand mit einem Widerstandswert von 100...120 Ohm zu installieren!

Das Ergebnis der vorherigen Skizze mit zwei angeschlossenen Sensoren könnte etwa so aussehen:

ROM = 28 88 84 82 5 0 0 6A

Daten = 1 51 1 4B 46 7F FF F 10 FE CRC=FE

Temperatur = 21,06 Grad Celsius, 69,91 Fahrenheit

ROM = 28 DA CA 27 5 0 0 49

Daten = 1 4E 1 4B 46 7F FF 2 10 D9 CRC=D9

Temperatur = 20,87 Celsius, 69,57 Fahrenheit

Keine Adressen mehr.

Den richtigen Sensor auswählen

Es wäre schön zu wissen, von welchem ​​Sensor Sie Daten erhalten, wenn Sie mehrere Sensoren parallel verwenden. Wie geht das?

Seriennummer

Da die Sensoren digital sind, verfügt jeder von ihnen über eine individuelle Seriennummer, mit der sich ein bestimmter Sensor identifizieren lässt. Alles scheint einfach zu sein. Aber... wir müssen zuerst diese Seriennummern identifizieren, bevor wir sie zur Identifizierung des Sensors verwenden können, oder?

Aus den obigen Beispielen können Sie ersehen, dass die Skizze uns Daten in Form einer 64-Bit-Seriennummer liefert – dem „ROM“-Wert. Zum Beispiel:

28 88 84 82 5 0 0 6A oder 28 DA CA 27 5 0 0 49 im Beispiel oben.

Vergessen Sie nicht, wenn Sie eine große Anzahl von Sensoren gleichzeitig verwenden (10 oder mehr), müssen Sie Widerstände von 100 ... 120 Ohm zwischen den Datenpins des DS18B20-Sensors und dem Datenpin des Arduino hinzufügen ( für jeden Sensor!).

Nachfolgend finden Sie ein Diagramm der Parallelschaltung mehrerer Sensoren mit drei Pins.

Hinterlassen Sie unten Ihre Kommentare, Fragen und teilen Sie Ihre persönlichen Erfahrungen. In Diskussionen entstehen oft neue Ideen und Projekte!

Das Sortiment unseres Shops umfasst jetzt den Temperatursensor DALLAS 18B20 im wasserdichten Gehäuse mit einem breiten Messbereich von -55 bis +125 °C. Daten zur Feuchtigkeitsbeständigkeit und einer maximalen Temperatur von +125 Grad ließen sofort über extreme Tests in kochendem Wasser nachdenken. Das werden wir tun.

Komponenten zur Wiederholung (in China kaufen):

Dieser Sensor arbeitet über einen 1-Wire-Bus.

Jedes dieser Geräte enthält einen einzigartigen 64-Bit-ROM-Code, der aus 8 Bits zur Definition des Seriencodes, 48 ​​Bits einer eindeutigen Zahl und 8 Bits eines rauschresistenten CRC-Codes besteht.

Informationen über die gemessene Temperatur werden im RAM des Sensors gespeichert, der aus 9 Bytes besteht.

1 Und 2 Bytes speichern Temperaturinformationen.

3 Und 4 Die Bytes speichern jeweils die oberen und unteren Temperaturgrenzen.

5 Und 6 Bytes sind reserviert.

7 Und 8 Bytes dienen der hochpräzisen Temperaturmessung.

9 Das Byte speichert den rauschresistenten CRC-Code der vorherigen 8 Bytes.

Grundlegende Befehle, die beim Arbeiten mit der Bibliothek verwendet werden:

search(addressArray)

Sucht nach dem nächsten 1-Wire-Gerät; wenn das Gerät gefunden wird, wird sein ROM-Code in das 8-Byte-AdressArray geschrieben, andernfalls wird false zurückgegeben.

reset_search()

Führt eine neue Suche vom ersten Gerät aus durch.

zurücksetzen()

Führt einen Bus-Reset durch, der vor der Kommunikation mit dem Sensor erforderlich ist.

select(addressArray)

Führt die Geräteauswahl nach dem Zurücksetzen durch, der ROM-Gerätecode wird übertragen.

schreiben(Byte)

Überträgt ein Informationsbyte an das Gerät

write(Byte, 1)

lesen()

Liest ein Informationsbyte vom Gerät

crc8(dataArray, Länge)

Berechnet den CRC-Code der Bytes aus dem dataArray, Länge Länge

Mit dem Schreibbefehl können wir Steuerbefehle in Form von Bytes an den Sensor übertragen. Schauen wir uns die wichtigsten an:

0x44- Temperaturmessungen durchführen und Daten in den RAM schreiben

0x4E- Schreiben Sie 3 Bytes in das 3., 4. und 5. Byte des RAM

0x48- Kopieren Sie das 3. und 4. Byte des RAM in das EEPROM

0xB8- Daten vom EEPROM in das 3. und 4. Byte des RAM kopieren

Anschließen an Arduino

Aus dem Sensor kommen drei Drähte heraus:

Rot:„+“ Leistung.

Schwarz:"-" Stromversorgung

Weiß: Ausgangspin

Sensoranschluss:

Rot: bei +5 Volt Arduino.

Schwarz an einen der GND-Pins --- Arduino.

Weiß an jeden Arduino-Digitaleingang (D10 im Beispiel).

Damit der Sensor funktioniert, muss die Signalleitung über einen 4,7-kOhm-Widerstand mit der Stromleitung verbunden werden.

Schauen wir uns zunächst das nützlichste Beispiel für die Arbeit mit einem Sensor an – die Ausgabe von Temperaturmesswerten an einen Portmonitor.

Beispielcode

#enthalten OneWire ds(10); // verbunden mit Pin 10 (4,7k Widerstand erforderlich) void setup(void) ( Serial.begin(9600); ) void loop(void) ( byte i; byte present = 0; byte type_s; byte data; byte addr; float Celsius, Fahrenheit; if (!ds.search(addr)) ( Serial.println("Keine weiteren Adressen."); Serial.println(); ds.reset_search(); delay(250); return; ) Serial. print("ROM ="); for(i = 0; i< 8; i++) { Serial.write(" "); Serial.print(addr[i], HEX); } if (OneWire::crc8(addr, 7) != addr) { Serial.println("CRC is not valid!"); return; } Serial.println(); // the first ROM byte indicates which chip switch (addr) { case 0x10: Serial.println(" Chip = DS18S20"); // or old DS1820 type_s = 1; break; case 0x28: Serial.println(" Chip = DS18B20"); type_s = 0; break; case 0x22: Serial.println(" Chip = DS1822"); type_s = 0; break; default: Serial.println("Device is not a DS18x20 family device."); return; } ds.reset(); ds.select(addr); ds.write(0x44, 1); // начало коммуникации delay(1000); present = ds.reset(); ds.select(addr); ds.write(0xBE); // читаем значение Serial.print(" Data = "); Serial.print(present, HEX); Serial.print(" "); for (i = 0; i < 9; i++) { // смотрим 9 байтов data[i] = ds.read(); Serial.print(data[i], HEX); Serial.print(" "); } Serial.print(" CRC="); Serial.print(OneWire::crc8(data, 8), HEX); Serial.println(); // Преобразуем получненный данные в температуру // Используем int16_t тип, т.к. он равен 16 битам // даже при компиляции под 32-х битный процессор int16_t raw = (data << 8) | data; if (type_s) { raw = raw << 3; if (data == 0x10) { raw = (raw & 0xFFF0) + 12 - data; } } else { byte cfg = (data & 0x60); if (cfg == 0x00) raw = raw & ~7; else if (cfg == 0x20) raw = raw & ~3; else if (cfg == 0x40) raw = raw & ~1; } celsius = (float)raw / 16.0; fahrenheit = celsius * 1.8 + 32.0; Serial.print(" Temperature = "); Serial.print(celsius); Serial.print(" Celsius, "); Serial.print(fahrenheit); Serial.println(" Fahrenheit"); }

Dallas18B20-Extremtest

Wie bereits erwähnt, haben wir uns entschieden, den Sensor einem extremen Test zu unterziehen, aber den Sensor einfach in kochendes Wasser zu legen, ist nicht interessant. Legen Sie den Sensor in ein Glas und kochen Sie ihn. Zur besseren Übersichtlichkeit werden die Temperaturwerte im Hafenmonitor angezeigt. Das unten angehängte Video zeigt einen allmählichen Temperaturanstieg. Ich möchte darauf hinweisen dass die Wassertemperatur bei normalem Atmosphärendruck nicht höher als 100 °C sein darf. Beim Testen des Sensors in kochendem Wasser betrug die von uns gemessene Höchsttemperatur 99,87 °C. Der Test kann als erfolgreich gewertet werden.

Dem Stromkreis wurde ein Relais hinzugefügt, um den Kessel bei einer Temperatur von 99,5 °C automatisch abzuschalten. Um die Kabel am Kessel nicht zu durchtrennen, verbinden wir ihn über eine Steckdose, in der sich das oben erwähnte Relais befindet.

Wichtig

Der Temperatursensor befindet sich in einem Metallgehäuse, der Übergang vom Metall zum Kabel ist mit Schrumpfschlauch isoliert. Bei Metall sitzt der Schlauch sehr fest, bei Kabeln ist er lockerer; an dieser Stelle kann Wasser austreten, allerdings ist die Wahrscheinlichkeit gering. Um diese Situation zu vermeiden, empfehlen wir, nicht den gesamten Sensor in Wasser zu tauchen. Sollten Sie dennoch einen solchen Bedarf haben, empfehlen wir Ihnen, diesen Bereich gründlicher zu isolieren.

Beispielcode

#enthalten OneWire ds(10); // verbunden mit Pin 10 (ein 4,7-k-Widerstand ist erforderlich) void setup(void) ( Serial.begin(9600); pinMode(3, OUTPUT); // Schalten Sie den Kessel ein digitalWrite(3, LOW); ) void loop (void) ( byte i; byte present = 0; byte type_s; byte data; byte addr; float celsius, fahrenheit; if (!ds.search(addr)) ( Serial.println("Keine weiteren Adressen."); Serial .println( ); ds.reset_search(); return;< 8; i++) { Serial.write(" "); Serial.print(addr[i], HEX); } if (OneWire::crc8(addr, 7) != addr) { Serial.println("CRC is not valid!"); return; } Serial.println(); // the first ROM byte indicates which chip switch (addr) { case 0x10: Serial.println(" Chip = DS18S20"); // or old DS1820 type_s = 1; break; case 0x28: Serial.println(" Chip = DS18B20"); type_s = 0; break; case 0x22: Serial.println(" Chip = DS1822"); type_s = 0; break; default: Serial.println("Device is not a DS18x20 family device."); return; } ds.reset(); ds.select(addr); ds.write(0x44, 1); // начало коммуникации delay(1000); present = ds.reset(); ds.select(addr); ds.write(0xBE); // читаем значение Serial.print(" Data = "); Serial.print(present, HEX); Serial.print(" "); for (i = 0; i < 9; i++) { // смотрим 9 байтов data[i] = ds.read(); Serial.print(data[i], HEX); Serial.print(" "); } Serial.print(" CRC="); Serial.print(OneWire::crc8(data, 8), HEX); Serial.println(); // Преобразуем получненный данные в температуру // Используем int16_t тип, т.к. он равен 16 битам // даже при компиляции под 32-х битный процессор int16_t raw = (data << 8) | data; if (type_s) { raw = raw << 3; if (data == 0x10) { raw = (raw & 0xFFF0) + 12 - data; } } else { byte cfg = (data & 0x60); if (cfg == 0x00) raw = raw & ~7; else if (cfg == 0x20) raw = raw & ~3; else if (cfg == 0x40) raw = raw & ~1; } celsius = (float)raw / 16.0; fahrenheit = celsius * 1.8 + 32.0; Serial.print(" Temperature = "); Serial.print(celsius); Serial.print(" Celsius, "); Serial.print(fahrenheit); Serial.println(" Fahrenheit"); // Если температура достигает температуры кипения (с погрешностью), отключаем кипятильник if (celsius >99,5) ( digitalWrite(3, HIGH); ) )

#enthalten

OneWire ds(10); // Den Sensor an den digitalen Pin 10 anschließen

void setup(void) (
Serial.begin(9600);
pinMode(3, OUTPUT);
// Schalten Sie den Kessel ein
digitalWrite(3, LOW);
}

Void-Schleife (Void) (
Byte i;
Bytetyp_s;
Byte-Daten;
Byte-Adresse;
Float Celsius, Fahrenheit;

// Suche nach der Sensoradresse
if (!ds.search(addr)) (
Serial.println("Keine weiteren Adressen.");
Serial.println();
ds.reset_search();
Verzögerung (250);
zurückkehren;
}

// Überprüfen Sie, ob während der Übertragung Störungen aufgetreten sind
if (OneWire::crc8(addr, 7) != addr) (
Serial.println("CRC ist ungültig!");
zurückkehren;
}
Serial.println();

// Bestimmen Sie die Sensorserie
Schalter (Adresse) (
Fall 0x10:
Serial.println("Chip = DS18S20");
type_s = 1;
brechen;
Fall 0x28:
Serial.println("Chip = DS18B20");
type_s = 0;
brechen;
Fall 0x22:
Serial.println("Chip = DS1822");
type_s = 0;
brechen;
Standard:
Serial.println("Gerät ist kein Gerät der DS18x20-Familie.");
zurückkehren;
}

ds.reset();
ds.select(addr);
ds.write(0xBE); // Lesen Sie den Sensor-RAM

für (i = 0; i< 9; i++) {
data[i] = ds.read(); // Füllen Sie das Array mit den gelesenen Daten
}

// Temperaturdaten sind in den ersten beiden Bytes enthalten, konvertieren Sie sie in einen Wert und konvertieren Sie sie in eine 16-Bit-Zahl
int16_t raw = (Daten<< 8) | data;
if (type_s) (
roh = roh<< 3;
if (Daten == 0x10) (
raw = (raw & 0xFFF0) + 12 – Daten;
}
}
anders(
Byte cfg = (Daten & 0x60);
if (cfg == 0x00) raw = raw & ~7;
sonst if (cfg == 0x20) raw = raw & ~3;
sonst if (cfg == 0x40) raw = raw & ~1;
}
Celsius = (float)raw / 16,0;
Fahrenheit = Celsius * 1,8 + 32,0;
Serial.print("Temp = ");
Serial.print(celsius);
Serial.print(" C, ");
Serial.print(fahrenheit);
Serial.println("F");

// Wenn die Temperatur den Siedepunkt erreicht (mit einem Fehler), schalten Sie den Kessel aus
wenn (Celsius > 99,5)
{
digitalWrite(3, HIGH);
}
}

Kaufen Sie in Russland

Es ist Zeit, sich etwas Nützlicherem auf dem Bauernhof zuzuwenden. Nun, stellen Sie zum Beispiel ein digitales Thermometer oder so etwas her. Außerdem ist es mit Arduino gar nicht mehr so ​​schwierig wie in der „Vor-Controller-Ära“. Damals war ein elektronisches Thermometer ein komplexes Gebilde bestehend aus einem Dutzend Mikroschaltungen, einem analogen Sensor, der noch kalibriert werden musste, und einem Transformator-Netzteil für mehrere Ausgangsspannungen. Nun, und - eine angemessene Ausbildung für den Funkamateur, der das alles sammeln möchte. Damit ist jetzt alles viel einfacher.

Lassen Sie mich vorstellen: einen digitalen Temperatursensor der bürgerlichen Firma „Dallas Semiconductor“ DS18B20.

Voll funktionsfähiges Gerät zur genauen (auf mehrere Dezimalstellen genauen) Temperaturmessung im Bereich von -55 bis +120 Grad Celsius. Darüber hinaus gibt es sogar ein paar „Gehirne“ (Gedächtniszellen), um sich etwas Nützliches zu merken. Aber wir werden sie vorerst nicht nutzen. Wie Sie auf dem Bild sehen können, ist es in mehreren Varianten erhältlich. Am gebräuchlichsten und bequemsten für uns ist die Angabe „TO-92“.

Der Sensor verfügt nur über 3 Pins, von denen zwei mit einer 5V-Versorgungsspannung versorgt werden und der mittlere Pin zur Datenübertragung dient. Die gesamte Steuerung des Sensors (Senden von Befehlen an ihn, Auslesen der gemessenen Temperatur) erfolgt über einen einzigen Leiter, weshalb diese gesamte Technologie und dieses Übertragungsprotokoll „1-Wire“ oder „One-Wire“ genannt werden.

Um uns nicht zu sehr mit der Theorie zu belasten, betrachten wir kurz den Vorgang der Temperaturmessung mit unserem Sensor.

Jede Datenübertragungs- oder Empfangssitzung beginnt mit einem Initialisierungsbefehl. Auch hier werden wir nicht auf die Einzelheiten der Kommunikation zwischen dem Arduina und dem Thermometer eingehen; Fremde haben dies für uns getan (wir werden ihnen im Geiste danken). Wir geben ihr nur einen Befehl – ​​„Initialisierung“, und sie wird herausfinden, was zu tun ist.

Als nächstes beginnen wir nach der Initialisierung mit der Ausgabe von Steuerbefehlen. Hierbei ist zu beachten, dass theoretisch mehrere Geräte der „1-Wire“-Familie an einer Steuerleitung angeschlossen sein können. Darüber hinaus nicht nur Temperatursensoren. Daher ist es möglich, auf jeden von ihnen über eine eindeutige Seriennummer zuzugreifen. Aber da wir einen einzigen Sensor am Kabel haben, können wir uns grundsätzlich nicht auf etwas anderes konzentrieren. Daher werden diese Vorspiele vom Befehl übersprungen (übertragen durch das „0xCC“-Byte). Ich habe vergessen zu erwähnen, dass hier und im Folgenden die hexadezimale Schreibweise von Binärzahlen (Bytes) verwendet wird.

Nachdem wir uns für den Empfänger entschieden haben, senden wir den Befehl „Temperatur messen“ („0x44“). Danach müssen Sie den Sensor etwa eine Sekunde lang in Ruhe lassen, während er seine Aufgabe erfüllt.

Während dieser Zeit misst „ds“ die Temperatur und schreibt die Ergebnisse in zwei Bytes, die wir daraus extrahieren und in eine menschliche Form umwandeln müssen. Wir beginnen wie immer mit der Initialisierung der Kommunikationssitzung. Anschließend übermitteln wir erneut den Befehl „Adressübertragung zurücksetzen“ („0xSS“). Und dann teilen wir Ihnen sofort mit, dass wir bereit sind, das Messergebnis zu akzeptieren: („0xBE“).

Danach empfängt Arduino nacheinander 2 Bytes (oder eine Zwei-Byte-Zahl – wie Sie möchten) mit den Ergebnissen. Schauen wir uns an, was diese Ergebnisse sind und wie wir sie in eine verdauliche Form bringen können.

Um nicht zu beschäftigt zu sein, sollten wir noch einmal entscheiden, was uns wichtig ist. Im Low- und teilweise High-Byte steht nämlich das auf die 4. Dezimalstelle genaue Ergebnis der Temperaturmessung (für uns ist eine solche Genauigkeit unnötig). Das Vorzeichen der Temperatur („+“ oder „-“) wird durch den Wert des höchstwertigen Bits des High-Byte bestimmt.

Aber genug der Worte – es ist Zeit, mit dem Entwerfen zu beginnen. Der Anschlussplan für den DS18B20 an den Arduino ist nicht nur einfach, sondern schlicht einfach:

Die Power-Pins des Sensors sind mit den entsprechenden Arduino-Pins verbunden und der Datenausgang ist mit dem Digitalausgang „10“ verbunden. Darüber hinaus ist der Datenausgang über einen 3 - 5 Kilo-Ohm-Widerstand (den sogenannten „Pull-up“-Widerstand) mit dem +5-Volt-Bus verbunden. Beachten Sie, dass der digitale Ausgang „10“ zwar sowohl als Ausgang als auch als Eingang fungiert, wir ihn jedoch nicht mehr konfigurieren müssen, wie im vorherigen Beispiel mit LEDs. Die Entwickler der „1-Wire“-Bibliothek haben uns sorgfältig von jeglicher Drecksarbeit befreit. Vielen Dank dafür!

Im Allgemeinen kam bei mir so etwas heraus:

Ja! Ich habe es völlig vergessen! Die „1-Wire“-Bibliothek ist nicht im Basispaket der Arduino IDE enthalten, Sie müssen sie also beispielsweise hier herunterladen. Entpacken wir das Archiv und legen den Ordner mit der Bibliothek im Verzeichnis \libraries ab, das sich in dem Ordner befindet, in dem die Arduino IDE installiert ist. Wenn Sie die Entwicklungsumgebung das nächste Mal starten, steht die Bibliothek zur Verwendung zur Verfügung. Hier finden Sie es:

Wir werden jedoch nicht die Skizze aus „Samples“ verwenden, da ist viel ausgefallenes Zeug dabei. Es ist besser, diese Skizze in die Arduino IDE zu kopieren:

#enthalten

OneWire ds(10); //

void setup(void) (
Serial.begin(9600); // Richten Sie die serielle Schnittstelle für die Ausgabe von Ergebnissen ein
}

void loop() (
Byte-Daten; // ein Array von 2 Bytes deklarieren
ds.reset(); // Initialisiere den Sensor
ds.write(0xCC); // Adressierung an einen bestimmten Sensor überspringen (wir haben einen)
ds.write(0x44); // Befehl zum Messen der Temperatur geben
Verzögerung (1000); // 1 Sekunde warten, während die Temperatur gemessen wird

ds.reset(); // den Sensor erneut initialisieren
ds.write(0xCC); // Adressierung erneut überspringen
ds.write(0xBE); // Befehl zum Ablesen der Temperatur geben
data = ds.read(); //niedrig lesen
data = ds.read(); // und High-Bytes
int Temp = (Daten<< 8) + data; // преобразуем считанную информацию
Temperatur = Temperatur >> 4; // zur gewünschten Ansicht.
Serial.println(Temp); // das Ergebnis an die serielle Schnittstelle ausgeben.

Was wir hier sehen... Zunächst wird die „OneWire“-Bibliothek mit dem Sketch verbunden. Wir geben an, dass unser Sensor an Pin „10“ des Arduino angeschlossen ist.Anschließend wird die serielle Schnittstelle für die Ausgabe der Messergebnisse konfiguriert. Das war's, die vorbereitenden Arbeiten sind abgeschlossen, wir beginnen mit der Messung. Wir bereiten 2 Bytes vor (reservieren und benennen), in die wir das Ergebnis der Temperaturmessung schreiben. Dann geben wir wie oben beschrieben Befehle aus und erhalten schließlich 2 Bytes mit unserer Temperatur. Anschließend werden die gelesenen Informationen konvertiert und zusätzliche Dezimalstellen entfernt, um den gesamten Temperaturwert ohne Dezimalstellen zu erhalten. Diese Informationen werden über die serielle Schnittstelle ausgegeben. Wo können wir sie sehen? Und hier ist es:

Laden Sie also diese Skizze auf Arduino hoch, öffnen Sie den „Serial Port Monitor“ und beobachten Sie jede Sekunde die gemessene Temperatur:

Hurra! Es funktioniert! Wir werden nicht im Detail auf den Prozess der Umwandlung von 2 vom Sensor empfangenen Bytes in eine ganzzahlige Temperaturzahl eingehen; dies ist ein Thema für einen separaten großen Artikel. Lassen Sie mich einfach sagen, dass die resultierende Zahl eine temporäre Variable vom Typ Ganzzahl ist. Das heißt, es kann sowohl positive als auch negative Werte annehmen. Lassen Sie uns die Funktion unseres Geräts bei Kälte überprüfen:

Nun, es zeigt auch Minustemperaturen. Auch gleich mit dem Schild. Wenn wir in Zukunft die Temperatur auf verschiedenen Indikatoren anzeigen, müssen wir uns diese Funktion unseres Programms merken. Und liefern einen zusätzlichen Hinweis auf das positive Temperaturzeichen. Aber mehr dazu in den folgenden Artikeln.

Bei der Untersuchung von Mikrocontrollern besteht früher oder später die Notwendigkeit, einen solchen meteorologischen Parameter der Umgebung wie die Temperatur zu messen. Der moderne globale Markt für elektronische Komponenten bietet ein breites Spektrum an Temperatursensoren. Die Hauptunterschiede zwischen ihnen sind der Bereich der gemessenen Temperatur, die Versorgungsspannung, der Anwendungsbereich, die Gesamtabmessungen, die Methoden der Temperaturumrechnung und die Schnittstelle für die Interaktion mit dem Benutzersteuerungssystem. Historisch gesehen ist der Sensor derzeit einer der beliebtesten Temperatursensoren DS18B20 Dallas Semiconductor Corporation. Die folgende Geschichte handelt von ihm.

DS18B20– digitaler Temperatursensor mit programmierbarer Wandlungsauflösung.

Besonderheiten:

1) Verwendung eines 1-Wire-Datenschnittstellenbusses zur Interaktion mit dem Steuerungssystem;
2) Das Vorhandensein eines eindeutigen seriellen 64-Bit-Identifikationscodes, der sich im internen ROM-Speicher befindet und für Mehrpunktsysteme vorgesehen ist, bei denen die Adressierung eines bestimmten Sensors erforderlich ist;
3) Die Versorgungsspannung beträgt 3-5,5 V, was den Einsatz nicht nur in 5-Volt-Systemen, sondern auch in 3,3 (die meisten Mikrocontroller) ermöglicht;
4) Der gemessene Temperaturbereich beträgt -55…+125 °C;
5) Genauigkeit von ±0,5 o C, obwohl dies nur für den Bereich -10...+85 o C gilt;
6) Die Konvertierungsauflösung wird vom Benutzer bestimmt und beträgt 9 bis 12 Bit.
7) Verfügt über interne Register der Auslöser der oberen und unteren Schwellenwerte mit der Erzeugung eines Alarmsignals für Systeme, die eine thermostatische Betriebslogik verwenden;
8) Diese Sensoren sind softwarekompatibel mit DS1822 und werden häufig in industriellen Thermostatreglern, Industriesystemen, Unterhaltungselektronik und anderen temperaturempfindlichen Systemen eingesetzt.

Beschreibung und Funktionsprinzip des Gerätes:

In meinem Artikel werde ich ein Beispiel für die Arbeit mit einem Sensor beschreiben, der in einem TO-92-Gehäuse hergestellt ist.

Es sieht so aus:

Das Innere dieser Sache ist sehr einfach, schauen Sie selbst:

Schauen wir uns dieses Blockdiagramm genauer an.

Allerdings bringt die Stromversorgung auf diese Weise einige Einschränkungen hinsichtlich der Zeitparameter des Sensors mit sich. Durch längeres Halten der Datenleitung wird der Kondensator entladen, was zur Abschaltung der INTERNEN Vdd-Leitung und dementsprechend des Sensors als Ganzes führt. Daher muss die DQ-Leitung in ungenutzten Zeiten hoch gehalten werden. Es gibt einen wichtigen Punkt zu beachten. Während der Temperaturumwandlung und dem Kopieren von Daten vom Scratchpad in das EEPROM (in eines der Register) kann der von der INTERNEN Vdd-Leitung verbrauchte Strom 1,5 mA erreichen, was zu viel für den internen Kondensator ist, und es kommt zu einem großen Spannungsabfall über den Pull-up-Widerstand, was den Betrieb des Geräts im Allgemeinen unzulässig beeinträchtigt. Dazu ist es notwendig, ein leistungsstarkes Pull-up-Schema für die DQ-Leitung zu organisieren, das nach dem folgenden Schema implementiert wird:

Nach Erteilen des Befehls KonvertierenT oder KopieNotizblock Es ist notwendig, spätestens nach 10 μs (max.) einen kräftigen Pull-up der DQ-Leitung mit einem MOSFET-Transistor einzuschalten, wie von den Sensorentwicklern angegeben, und dann die Konvertierungszeit (Tconv) bzw. Datenübertragungszeit abzuwarten (Twr = 10 ms) und während dieser Zeit keine Aktionen bei eingeschaltetem leistungsstarken Pull-Up. Es sollte kein DQ auf der Leitung sein!

Über die Standard-Stromversorgung muss man wenig sagen, denn hier ist alles einfach und selbst ein MOSFET wird überhaupt nicht benötigt:

Das Subsystem „64-BIT ROM AND 1-Wire PORT“ enthält einen eindeutigen seriellen 64-Bit-Identifikationscode, der sich im nichtflüchtigen ROM-Speicher befindet. Dieser Knoten enthält auch die Schnittstelle für die Interaktion mit dem 1-Wire-Steuerungssystem. Das Subsystem „Memory Control Logic“ führt Datenübertragungen zwischen dem 1-Wire-Schnittstellensubsystem und dem Speicher vom Typ Scratchpad durch, der wiederum Zugriff auf die Temperatursensorregister, Register zum Einstellen der oberen und unteren Alarmschwellen sowie das Konfigurationsregister hat und das 8-Bit-Prüfsummenregister, um das System vor falschen Daten zu schützen.

Wenn der Sensor standardmäßig eingeschaltet ist, verfügt er über eine 12-Bit-Konvertierungsauflösung und wechselt sofort in einen Energiesparmodus. Um die Konvertierung einzuleiten, muss das Master-Gerät den Befehl senden KonvertierenT . Nach der Umwandlung der Temperatur in einen digitalen Code liegt dieser Code als Zwei-Byte-Wort im Scratchpad-Speicher und der Sensor geht wieder in den Energiesparmodus.

Temperaturumrechnung.

Lassen Sie uns nun herausfinden, wie die Temperatur im Sensor umgewandelt wird. Im Wesentlichen befindet sich ein ADC im Temperatursensor selbst und die im Temperaturregister befindlichen Ausgabedaten werden an den Scratchpad-Speicher übertragen. Temperaturdaten haben das folgende Format:

Flag S – Vorzeichenflag, das verwendet wird, um das Vorzeichen der Zahl anzuzeigen (S=0 – die in den Bits 10-0 enthaltene Zahl ist positiv, und S=1, wenn die in den gleichen Bits enthaltene Zahl negativ ist, d. h. in diesem Fall die Temperatur wird im Zweierkomplement-Code dargestellt).

Bei Konfiguration für eine 12-Bit-Konvertierungsauflösung sind alle 12 Bits (Bit 11-Bit 0) aktiviert und enthalten gültige Daten. Bei einer Auflösung von 11 Bit sollte der Inhalt von Bit 0 ignoriert werden, bei einer Auflösung von 10 Bit sollten die Bits 0 und 1 ignoriert werden usw.

Der Alarm ist eine Funktion des Thermostats.

Zu diesem Zweck stehen 2 8-Bit-Register zur Verfügung, Th und Tl. Th enthält den Wert der oberen Temperaturschwelle und Tl den entsprechenden unteren Schwellenwert. Wenn die Temperatur höher als Th oder niedriger als Tl ist, wird ein Alarmflag gesetzt. Dieses Alarmflag wird vom Master durch Ausgabe des Befehls erkannt Alarmsuche zur DQ-Linie. Das Alarmflag wird nach jedem Temperaturumwandlungsvorgang aktualisiert. Im Vergleich zum Th- oder Tl-Register werden übrigens nur die Bits 11 bis 4 des Temperaturregisters verwendet, was bedeutet, dass die Thermostatfunktion nur für ganzzahlige Temperaturwerte funktioniert. Bei den Registern handelt es sich physikalisch um EEPROM-Speicher, sodass sie ihre Werte behalten, wenn der Strom ausgeschaltet wird. Die Register selbst ähneln dem Temperaturregister, nur sind sie 8-Bit, das S-Flag hat absolut die gleiche Bedeutung wie im vorherigen Fall:

Dieser Code ist, wie bereits erwähnt, erforderlich, um in Mehrpunkt-Temperaturmesssystemen jedes Gerät in der Leitung zu identifizieren.

Das Format dieses Speichers ist:

Die unteren 8 Bits sind für die Familienbezeichnung reserviert und enthalten den Wert 0x28. Die nächsten 48 Bits enthalten die eindeutige Seriennummer des Geräts. Das höchstwertige Byte enthält den Wert der CRC-Prüfsumme, die für die unteren 56 Bits des ROM-Speichers berechnet wurde.

Organisation des Gedächtnisses.

Der Sensorspeicher besteht aus einem Scratchpad-Speicherplatz (Scratchpad) und einem EEPROM-Speicher zur Speicherung von Konfigurationsdaten und den Werten der oberen und unteren Alarmschwellenregister.

Beim Ausschalten der Stromversorgung bleiben die Daten in den Bytes 2, 3 und 4 im EEPROM erhalten. Nun, wenn sie eingeschaltet sind, bleiben die darin enthaltenen Werte unverändert. Die Bytes 0 und 1 enthalten den umgerechneten Temperaturwert, die Bytes 5, 6, 7 sind für den internen Gebrauch reserviert und für den Benutzer nicht für seine Zwecke zugänglich.

Das 8. Byte enthält den von der integrierten CRC-Code-Generierungslogik generierten Wert für die Bytes 0 bis 7, wodurch die Möglichkeit einer letztendlich fehlerhaften Temperaturbestimmung minimiert wird.

Es ist zu beachten, dass die Th- und Tl-Register als Allzweckspeicher verwendet werden können, wenn die Thermostatfunktion nicht verwendet wird – Sie können darin beliebige Informationen speichern.

Mit dem Befehl werden Daten in die Bytes 2, 3 und 4 geschrieben, beginnend mit dem niedrigstwertigen Bit von Byte 2 Schreiben Sie Scratchpad. Um die Integrität der aufgezeichneten Daten zu überprüfen, können Sie diese auslesen, wofür Sie einen Befehl an den Sensor senden müssen Lesen Sie Scratchpad Danach muss das Master-Gerät Daten beginnend mit dem niedrigstwertigen Bit von Byte 0 empfangen.

Um Daten aus den Hoch- und Tieftemperaturregistern sowie dem Konfigurationsregister im EEPROM-Speicher zu speichern, muss das Master-Gerät einen Befehl an den Sensor senden Scratchpad kopieren.

Wie bereits erwähnt, bleiben bereits in das EEPROM geschriebene Daten erhalten, wenn der Strom ausgeschaltet wird. Beim Einschalten werden die Werte aus den entsprechenden EEPROM-Zellen jedoch automatisch in die entsprechenden Scratchpad-Speicherregister geladen. Praktisch, nicht wahr? :)

Darüber hinaus können im EEPROM aufgezeichnete Daten jederzeit in den Arbeitsspeicher überschrieben werden. Dies ist beispielsweise erforderlich, wenn Sie während des Betriebs die Konfiguration geändert haben und anschließend in den „normalen Betriebsmodus“ zurückkehren müssen, d. h. Gibt die Betriebskonfiguration zurück, die vor der Änderung des Inhalts der Scratchpad-Speicherregister war. Eigentlich muss dazu das Master-Gerät einen Befehl an den Sensor senden Erinnern Sie sich an E2 .

Im Konfigurationsregister können vom Benutzer nur 2 Bits definiert werden: R0 und R1. Diese Bits bestimmen die Temperaturkonvertierungsauflösung und sind standardmäßig auf 1 eingestellt, was die Anfangseinstellung für die 12-Bit-Konvertierungsauflösung bestimmt.

Alle möglichen Konfigurationen dieser Bits und ihre entsprechenden Auflösungen sind in der folgenden Tabelle aufgeführt. Es ist zu beachten, dass die Konvertierungszeit umso länger ist, je höher die Konvertierungsauflösung ist. Bei einer 12-Bit-Auflösung beträgt die Konvertierungszeit beispielsweise 750 ms (maximal).

Interaktion mit dem Steuerungssystem.

DS18B20 verwendet, wie bereits erwähnt, eine 1-Wire-Datenschnittstelle für die Kommunikation mit dem Slave-Gerät. Um es anzuschließen, muss das Steuersystem daher einen Ausgang mit offenem Drain oder mit einem Hi-Z-Leitungszustand bereitstellen.

Die interne Konfiguration der Sensorschnittstelle ist unten dargestellt:

Im inaktiven Zustand (Ruhezustand) wird die DQ-Leitung über einen Widerstand an die „+“-Stromversorgung gezogen. Daher muss diese Leitung zwischen Transaktionen (Datenübertragungen) immer in diesem Zustand gehalten werden. Wenn Transaktionen aus irgendeinem Grund ausgesetzt werden müssen, muss die DQ-Linie hoch gehalten werden, damit die Übertragung wieder aufgenommen werden kann. Während des Stoppvorgangs der Transaktion können wir die DQ-Leitung ab 1 μs beliebig lange auf einem hohen logischen Pegel halten. Wenn der Datenbus jedoch länger als 480 µs auf einem niedrigen Logikpegel gehalten wird, kommt es zu einem vollständigen Reset aller auf diesem Bus vorhandenen Sensoren.

Reihenfolge der Vorgänge beim Austausch.

Bei jedem Zugriff des Steuerungssystems auf den Sensor ist die folgende Abfolge von Aktionen einzuhalten:

1) Initialisierung;
2) ROM-Befehl (gefolgt vom erforderlichen Datenaustausch);
3) Funktionsbefehl des Sensors (gefolgt vom notwendigen Datenaustausch).

Wenn beim Zugriff auf den Sensor ein Schritt fehlt, reagiert der Sensor nicht. Die Ausnahme bilden Teams SuchenROM [ F0 H] Und AlarmSuchen [ ECh] , Nach Abschluss muss der Master zum ersten Schritt der Steuersequenz zurückkehren.

Also. Alle Transaktionen beginnen mit der Initialisierung. Begleitet wird dieser Vorgang von der Erzeugung eines Reset-Impulses durch das Master-Gerät, woraufhin die Slave-Geräte (in diesem Fall die Sensoren) einen Anwesenheitsimpuls an den Master senden, der ihm mitteilt, dass die Sensoren angeschlossen und betriebsbereit sind .

Im Allgemeinen definiert der im Sensor implementierte 1-Wire-Schnittstellenbus mehrere Arten von Signalen auf der Datenleitung: Reset-Impuls, Präsenzimpuls, Schreiben 0, Schreiben 1, Lesen 0, Lesen 1. Alle diese Vorgänge werden vom Master-Gerät implementiert , mit Ausnahme des Präsenzimpulses. Es wird nur durch den/die Sensor(en) erzeugt.

Das Master-Gerät schaltet also zunächst in den Sendermodus und setzt die DQ-Leitung für eine Zeit von mindestens 480 μs auf 0 (fett schwarz hervorgehoben). Dadurch wird der Sensor zurückgesetzt. Anschließend muss die Leitung freigegeben und das Master-Gerät in den Empfängermodus versetzt werden, wobei der Pull-up-Widerstand die Datenleitung auf logisch hoch setzt (dünn schwarz hervorgehoben). Nachdem der Sensor eine steigende Flanke erkennt, wartet der Sensor 15–60 µs und setzt über seine Hardwareschnittstelle die Datenleitung auf 0 zurück und hält sie 60–240 µs lang. Nach Ablauf dieser Zeit gibt der Sensor die Leitung frei und wird für mindestens 480 μs auf den Logikpegel 1 gesetzt, nachdem der Sensor den Reset-Impuls erkannt hat.

Lassen Sie uns nun darüber sprechen, wie der Datenübertragungsprozess durchgeführt wird. Im Allgemeinen Bitübertragung. Der Punkt ist dieser. Es wird eine Zeitspanne benötigt, und während dieser Zeit schaut der Master, was sich auf unserer Leitung befindet. Nehmen wir an, 1 bedeutet, dass wir 1 geschrieben haben, wenn 0 bedeutet, dass wir Null geschrieben haben. Dies ist jedoch nur eine abstrakte Erklärung. Tatsächlich gibt es einige Nuancen im Zusammenhang mit dem Zeitrahmen dieser ganzen Angelegenheit.

Schauen wir uns die Bilder an:

Alles beginnt damit, dass der Master die gegebene Leitung auf einen niedrigen Logikpegel absenken muss, und ab diesem Moment beginnt der Schreib-/Leseschlitz 1/0, der 60 bis 120 µs dauert. Zwischen den Schreib-/Lese-Slots muss die Datenleitung für eine Zeit, die nicht kürzer als die Wiederherstellungszeit (1 μs) ist, auf 1 gesetzt werden. Um den Schreibsteckplatz 0 zu organisieren, müssen Sie die Datenleitung für den gesamten Steckplatz auf 0 halten. Wenn Sie auf Sensor 1 schreiben müssen, setzen Sie die Datenleitung zunächst auf 0 zurück, warten Sie dann mindestens 1 μs und geben Sie die Leitung auf 1 frei. Während des Schreibschlitzes 1 (60–120 µs) wird 1 auf den Sensor geschrieben (siehe Abbildung oben rechts).

Tatsächlich wird, wenn innerhalb von 15–60 µs nach dem Start eine 1 auf der Datenleitung erkannt wird, eine 1 geschrieben, und wenn innerhalb von 60–240 µs eine 0 erkannt wird, wird eine 0 geschrieben.

Das Lesen der Daten wird vom Master-Gerät begleitet, wenn es die Leitung zurücksetzt, mindestens 1 µs wartet und 15 µs lang beobachtet, was auf der Leitung passiert: Wenn 0 übrig bleibt, sendet der Sensor 0, wenn er auf 1 wechselt , dann wird 1 übertragen.

Mannschaften.

ROM-Befehle.

Diese Befehle müssen der Initialisierungssequenz folgen und Anweisungen zur Suche nach dem entsprechenden Sensor usw. enthalten. Die Breite jedes Befehls beträgt 8 Bit. Nach Ausführung des entsprechenden Befehls können Sie einen Funktionsbefehl an den Sensor senden.

Funktionale Teams.

Diese Befehle führen funktionale Vorgänge beliebiger Prozesse aus, z. B. das Starten einer Temperaturumwandlungsoperation, das Kopieren des Speichers usw. Insgesamt gibt es 6 Befehle mit jeweils 8 Bit.

Das ist in der Tat die ganze Weisheit der Arbeit mit dem Temperatursensor DS18B20. Genauere Informationen finden Sie im Datenblatt (). Jetzt müssen wir das Ganze in Hardware umsetzen.

Schematische Darstellung des Gerätes:

Zusammenbauzeichnung der Leiterplatte (Ich entschuldige mich für die Qualität, ich habe es nur zur Arbeit und zum Debuggen gemacht):

Vergessen Sie nicht, die Tafel richtig zu spiegeln

Da es sich um ein Steckbrett handelt, habe ich es aus einem alten Projekt herausgeholt, sodass das oben gezeigte Brett etwas anders ist als das, was ich habe (auf meinem habe ich jetzt alle unnötigen Dinge entfernt und es ist genau wie auf den Bildern oben).

Folgendes habe ich bekommen:

Es ist wie ein Sandwich geworden

Der Quellcode des Programms wurde in der Entwicklungsumgebung geschrieben. Ich habe nicht versucht, das Maximum an vorgefertigten Bibliotheken des avr-gcc-Compilers zu nutzen, sondern habe alles, wie man sagt, „von Hand“ geschrieben. Mein Ziel ist nicht die Demonstration der Beherrschung von C, sondern lediglich ein in einer Stunde geschriebenes Beispiel, das Anfängern ein allgemeines Verständnis für die Arbeit mit dem Sensor vermitteln kann.
Das Gerät ist für den Einsatz im Raum vorgesehen und ermöglicht daher keine Messung negativer Temperaturen.

Sie können die Quellen und die LAY-Leiterplatte unten herunterladen

Alle weiteren Fragen und Wünsche gerne unter: [email protected]