Digitales Thermometer mit Mikrocontroller lm35 und 8051

Manchmal fällt es Menschen aufgrund von Schwankungen schwer, die Temperatur vom analogen Thermometer abzulesen. Hier bauen wir ein einfaches digitales Thermometer mit einem 8051-Mikrocontroller, in dem der LM35-Sensor zur Temperaturmessung verwendet wird. Wir haben LM35 auch verwendet, um ein digitales Thermometer mit Arduino, NodeMCU, PIC, Raspberry Pi und anderen Mikrocontrollern zu bauen.

Dieses Projekt wird auch als ordnungsgemäße Schnittstelle zwischen ADC0804 und 8051 und 16 * 2 LCD mit 8051-Mikrocontroller dienen.

Erforderliche Komponenten:

8051 Entwicklungsboard
ADC0804-Karte
16 * 2 LCD-Anzeige
LM35 Sensor
Potentiometer
Überbrückungsdrähte

Schaltplan:

Das Schaltbild für die digitale Thermometerschaltung mit LM35 ist unten angegeben:

Temperaturmessung mit LM35 mit 8051:

Der 8051-Mikrocontroller ist ein 8-Bit-Mikrocontroller mit 128 Byte On-Chip-RAM, 4 KByte On-Chip-ROM, zwei Timern, einem seriellen Port und vier 8-Bit-Ports. Der 8052-Mikrocontroller ist eine Erweiterung des Mikrocontrollers. Die folgende Tabelle zeigt den Vergleich von 8051 Familienmitgliedern.

Merkmal	8051	8052
ROM (in Bytes)	4K	8 TAUSEND
RAM (Bytes)	128	256
Timer	2	3
E / A-Pins	32	32
Serielle Schnittstelle	1	1
Quellen unterbrechen	6	8

16x2 LCD:

16 * 2 LCD ist ein weit verbreitetes Display für eingebettete Anwendungen. Hier finden Sie eine kurze Erläuterung der Stifte und der Funktionsweise des 16 * 2-LCD-Displays. Es gibt zwei sehr wichtige Register im LCD. Sie sind Datenregister und Befehlsregister. Das Befehlsregister wird zum Senden von Befehlen wie Löschen der Anzeige, Cursor zu Hause usw. verwendet. Das Datenregister wird zum Senden von Daten verwendet, die auf dem 16 * 2-LCD angezeigt werden sollen. Die folgende Tabelle zeigt die Pin-Beschreibung von 16 * 2 LCD.

Stift	Symbol	I / O.	Beschreibung
1	Vss	- -	Boden
2	Vdd	- -	+ 5V Stromversorgung
3	Vee	- -	Netzteil zur Kontrastregelung
4	RS	ich	RS = 0 für Befehlsregister, RS = 1 für Datenregister
5	RW	ich	R / W = 0 zum Schreiben, R / W = 1 zum Lesen
6	E.	I / O.	Aktivieren
7	D0	I / O.	8-Bit-Datenbus (LSB)
8	D1	I / O.	8-Bit-Datenbus
9	D2	I / O.	8-Bit-Datenbus
10	D3	I / O.	8-Bit-Datenbus
11	D4	I / O.	8-Bit-Datenbus
12	D5	I / O.	8-Bit-Datenbus
13	D6	I / O.	8-Bit-Datenbus
14	D7	I / O.	8-Bit-Datenbus (MSB)
15	EIN	- -	+ 5V für Hintergrundbeleuchtung
16	K.	- -	Boden

Die folgende Tabelle zeigt häufig verwendete LCD-Befehlscodes.

Code (hex)	Beschreibung
01	Bildschirm löschen
06	Cursor erhöhen (Rechtsverschiebung)
0A	Anzeige aus, Cursor ein
0C	Anzeige ein, Cursor aus
0F	Anzeige ein, Cursor blinkt
80	Zwingen Sie den Cursor von 1 bis Anfang ^st Linie
C0	Zwingen Sie den Cursor von 2 bis Anfang ^nd Linie
38	2 Zeilen und 5 * 7 Matrix

ADC0804 IC:

Der ADC0804-IC ist ein paralleler 8-Bit-ADC aus der Familie der ADC0800-Serie von National Semiconductor. Es arbeitet mit +5 Volt und hat eine Auflösung von 8 Bit. Die Schrittgröße und der Vin-Bereich variieren für verschiedene Werte von Vref / 2. Die folgende Tabelle zeigt die Beziehung zwischen Vref / 2 und Vin-Bereich.

Vref / 2 (V)	Vin (V)	Schrittweite (mV)
öffnen	0 bis 5	19.53
2.0	0 bis 4	15.62
1.5	0 bis 3	11.71
1.28	0 bis 2,56	10

In unserem Fall ist Vref / 2 an 1,28 Volt angeschlossen, sodass die Schrittgröße 10 mV beträgt. Für ADC0804 wird die Schrittgröße als (2 * Vref / 2) / 256 berechnet.

Die folgende Formel wird zur Berechnung der Ausgangsspannung verwendet:

Dout = Vin / Schrittweite

Wenn Dout eine digitale Datenausgabe in Dezimalzahl ist, ist Vin = analoge Eingangsspannung und Schrittgröße (Auflösung) die kleinste Änderung. Erfahren Sie hier mehr über ADC0804 und überprüfen Sie auch die Schnittstelle von ADC0808 mit 8051.

LM35 Temperatursensor:

Der LM35 ist ein Temperatursensor, dessen Ausgangsspannung linear proportional zur Celsius-Temperatur ist. Der LM35 wird bereits kalibriert geliefert und erfordert daher keine externe Kalibrierung. Es gibt 10 mV für jeden Grad Celsius-Temperatur aus.

Der LM35-Sensor erzeugt eine der Temperatur entsprechende Spannung. Diese Spannung wird vom ADC0804 in digital (0 bis 256) umgewandelt und dem Mikrocontroller 8051 zugeführt. Der Mikrocontroller 8051 wandelt diesen digitalen Wert in eine Temperatur in Grad Celsius um. Dann wird diese Temperatur in eine ASCII-Form umgewandelt, die zur Anzeige geeignet ist. Diese ASCII-Werte werden 16 * 2 lcd zugeführt, wodurch die Temperatur auf dem Bildschirm angezeigt wird. Dieser Vorgang wird nach dem angegebenen Intervall wiederholt.

Unten sehen Sie das Setup-Bild für das digitale Thermometer LM35 mit 8051:

Alle digitalen Thermometer auf LM35-Basis finden Sie hier.

Code-Erklärung:

Das vollständige C-Programm für dieses digitale Thermometer mit LM35 finden Sie am Ende dieses Projekts. Der Code ist in kleine sinnvolle Abschnitte unterteilt und wird unten erläutert.

Für die 16 * 2-LCD-Schnittstelle mit dem 8051-Mikrocontroller müssen Pins definiert werden, an denen 16 * 2-LCD mit dem 8051-Mikrocontroller verbunden sind. Der RS-Pin von 16 * 2 lcd ist mit P2.7 verbunden, der RW-Pin von 16 * 2 lcd ist mit P2.6 verbunden und der E-Pin von 16 * 2 lcd ist mit P2.5 verbunden. Datenpins sind mit Port 0 des 8051-Mikrocontrollers verbunden.

sbit rs = P2 ^ 7; // Register Select (RS) Pin von 16 * 2 lcd sbit rw = P2 ^ 6; // Lese- / Schreibstift (RW) von 16 * 2 lcd sbit en = P2 ^ 5; // Aktiviere (E) Pin von 16 * 2 lcd

In ähnlicher Weise müssen wir für die ADC0804-Schnittstelle mit dem 8051- Mikrocontroller Pins definieren, an denen ADC0804 mit dem 8051-Mikrocontroller verbunden ist. Der RD-Pin von ADC0804 ist mit P3.0 verbunden, der WR-Pin von ADC0804 ist mit P3.1 verbunden und der INTR-Pin von ADC0804 ist mit P3.2 verbunden. Datenpins sind mit Port 1 des 8051-Mikrocontrollers verbunden.

sbit rd_adc = P3 ^ 0; // Lese (RD) Pin von ADC0804 sbit wr_adc = P3 ^ 1; // Schreib (WR) Pin von ADC0804 sbit intr_adc = P3 ^ 2; // Interrupt (INTR) Pin von ADC0804

Als nächstes müssen wir einige Funktionen definieren, die im Programm verwendet werden. Die Verzögerungsfunktion wird verwendet, um eine bestimmte Zeitverzögerung zu erstellen, die c mdwrt- Funktion wird verwendet, um Befehle an die 16 * 2-LCD-Anzeige zu senden, die datawrt- Funktion wird verwendet, um Daten an die 16 * 2-LCD-Anzeige zu senden, und die convert_display- Funktion wird verwendet, um die ADC-Daten in Temperatur umzuwandeln und um es auf einem 16 * 2 LCD-Display anzuzeigen.

ungültige Verzögerung (unsigned int); // Funktion zum Erstellen einer Verzögerung void cmdwrt (unsigned char); // Funktion zum Senden von Befehlen an 16 * 2 lcd display void datawrt (vorzeichenloses Zeichen); // Funktion zum Senden von Daten an 16 * 2 lcd display void convert_display (vorzeichenloses Zeichen); // Funktion zum Konvertieren des ADC-Werts in eine Temperatur und Anzeigen auf einem 16 * 2-LCD-Display

Im folgenden Teil des Codes senden wir Befehle an 16 * 2 lcd. Befehle wie klare Anzeige, Cursor - Inkrement, zwingen die Cursor von 1 bis beginnend ^st Zeile wird durch einen nach einer spezifizierten Zeitverzögerung bis 16 * 2 LCD - Anzeige eines gesendet.

for (i = 0; i <5; i ++) // Befehle an 16 * 2 senden lcd zeigt jeweils einen Befehl an {cmdwrt (cmd); // Funktionsaufruf zum Senden von Befehlen an 16 * 2 LCD-Anzeigeverzögerung (1); }}

In diesem Teil des Codes senden wir Daten an 16 * 2 lcd. Daten, die auf einem 16 * 2-LCD-Display angezeigt werden sollen, werden nach einer bestimmten Zeitverzögerung einzeln angezeigt.

für (i = 0; i <12; i ++) // Daten an 16 * 2 senden lcd zeigt jeweils ein Zeichen an {datawrt (data1); // Funktionsaufruf zum Senden von Daten an 16 * 2 LCD-Anzeigeverzögerung (1); } In diesem Teil des Codes wandeln wir die vom LM35-Sensor erzeugte analoge Spannung in digitale Daten um. Anschließend wird sie in Temperatur umgewandelt und auf einem 16 * 2-LCD-Display angezeigt. Damit ADC0804 die Konvertierung startet, müssen wir einen niedrigen bis hohen Impuls am WR-Pin von ADC0804 senden und dann auf das Ende der Konvertierung warten. INTR wird am Ende der Konvertierung niedrig. Sobald INTR niedrig wird, wird RD niedrig gemacht, um die digitalen Daten auf Port 0 des 8051-Mikrocontrollers zu kopieren. Nach einer festgelegten Zeitverzögerung beginnt der nächste Zyklus. Dieser Vorgang wird für immer wiederholt.

while (1) // für immer wiederholen {wr_adc = 0; // Sende LOW to HIGH Impuls bei WR Pin Delay (1); wr_adc = 1; while (intr_adc == 1); // warte auf das Ende der Konvertierung rd_adc = 0; // mache RD = 0, um die Daten von ADC0804 zu lesen value = P1; // ADC-Daten kopieren convert_display (Wert); // Funktionsaufruf zur Umwandlung von ADC-Daten in Temperatur und Anzeige auf 16 * 2 LCD-Anzeigeverzögerung (1000); // Intervall zwischen jedem Zyklus rd_adc = 1; // mache RD = 1 für den nächsten Zyklus}

Im folgenden Teil des Codes senden wir Befehle an die 16 * 2-LCD-Anzeige. Der Befehl wird auf Port 0 des 8051-Mikrocontrollers kopiert. RS wird für das Schreiben von Befehlen niedrig gemacht. RW wird für den Schreibvorgang auf niedrig gesetzt. Ein hoher bis niedriger Impuls wird an den Aktivierungsstift (E) angelegt, um den Befehlsschreibvorgang zu starten.

void cmdwrt (vorzeichenloses Zeichen x) {P0 = x; // sende den Befehl an Port 0, an dem 16 * 2 lcd angeschlossen ist rs = 0; // mache RS = 0 für den Befehl rw = 0; // mache RW = 0 für Schreiboperation en = 1; // Sende einen HIGH to LOW-Impuls am Enable (E) -Pin, um die Verzögerung der Befehlsschreiboperation zu starten (1); en = 0; }}

In diesem Teil des Codes senden wir Daten an das 16 * 2-LCD-Display. Die Daten werden auf Port 0 des 8051-Mikrocontrollers kopiert. RS ist für das Schreiben von Befehlen hoch eingestellt. RW wird für den Schreibvorgang auf niedrig gesetzt. Ein hoher bis niedriger Impuls wird an den Freigabepin (E) angelegt, um den Datenschreibvorgang zu starten.

void datawrt (vorzeichenloses Zeichen) {P0 = y; // sende die Daten an Port 0, an dem 16 * 2 lcd angeschlossen ist rs = 1; // mache RS = 1 für den Befehl rw = 0; // mache RW = 0 für Schreiboperation en = 1; // Sende einen HIGH to LOW-Impuls am Enable (E) -Pin, um die Verzögerung des Datenschreibvorgangs zu starten (1); en = 0; }}

In diesem Teil des Codes wandeln wir digitale Daten in Temperatur um und zeigen sie auf einem 16 * 2-LCD-Display an.

void convert_display (vorzeichenloser Zeichenwert) {vorzeichenloses Zeichen x1, x2, x3; cmdwrt (0xc6); // Befehl zum Setzen des Cursors auf die 6. Position der 2. Zeile auf 16 * 2 lcd x1 = (Wert / 10); // dividiere den Wert durch 10 und speichere den Quotienten in der Variablen x1 x1 = x1 + (0x30); // konvertiere die Variable x1 in ascii durch Addition von 0x30 x2 = Wert% 10; // dividiere den Wert durch 10 und speichere den Rest in der Variablen x2 x2 = x2 + (0x30); // konvertiere die Variable x2 in ASCII durch Hinzufügen von 0x30 x3 = 0xDF; // ASCII-Wert des Grads (°) Symbols datawrt (x1); // Anzeigetemperatur auf 16 * 2 LCD-Anzeigedaten (x2); datawrt (x3); datawrt ('C'); }}

Überprüfen Sie auch andere Thermometer mit LM35 mit anderen Mikrocontrollern:

Digitales Thermometer mit Arduino und LM35
Temperaturmessung mit LM35 und AVR Microcontroller
Raumtemperaturmessung mit Raspberry Pi