I2C-Temperatursensor LM75
Funktionsprinzip
El IC LM75 ist ein Silizium-Halbleiter-Bandlücken-Temperatursensor.
Bei Halbleitern ist die verbotene Band Es ist die Energiezone der Elektronen, die mit einer Erhöhung des elektrischen Feldes nicht vergrößert werden kann, da keine Zustände für eine schnellere Bewegung verfügbar sind. Das verbotene Band liegt zwischen den Valenzband (geringere Energie) und die Fahrband (höhere Energie). Durch thermische Anregung (der Temperaturanstieg für die Zwecke, die uns interessieren) können einige Elektronen genug Energie gewinnen, um in den Körper zu gelangen Fahrband.
Wie im vorherigen Artikel darüber erläutert elektronische TemperaturmessungIn Metallen hängt zwar die Anzahl der Ladungsträger nicht von der Temperatur ab (alle Elektronen sind immer verfügbar), ihre Beweglichkeit wird jedoch von der Temperatur beeinflusst, sodass der Widerstand in Metallen mit der Temperatur zunimmt, da die Geschwindigkeit der Elektronen abnimmt die Zunahme ihrer thermische Bewegung und die Streuung der Elektronen, die es erzeugt.
Im Fall von Halbleitern aufgrund des Vorhandenseins dieser verbotene Band Die Anzahl der Träger hängt von der Temperatur ab (je nach Fermi-Dirac-Verteilung), wodurch die Leitfähigkeit mit der Temperatur zunimmt. Bei Halbleitern führt eine Temperaturerhöhung zu einer Erhöhung des Widerstands, aber auch zu einer (weiteren) Erhöhung der Leitfähigkeit.
Die Silizium-Halbleiter-Bandlücken-TemperatursensorenLM75 arbeiten nach diesem Prinzip und ermöglichen die Bestimmung der Temperatur durch Quantifizierung ihres Einflusses auf die Spannung in einer Siliziumdiode.
LM75-Hardwarekomponenten
Der LM75 verfügt außerdem über eine Analog-Digital-Wandler durch Sigma-Delta-Modulation Dieser ist dafür verantwortlich, den numerischen (digitalen) Wert der Temperatur zu ermitteln, der anschließend (alle 100 ms) in einem seiner Register gespeichert wird und aus dem er über den Bus ausgelesen werden kann I2C.
Zusätzlich zu dem Register, das die gemessene Temperatur enthält, verfügt der LM75 über ein Register, in dem eine maximale Temperatur gespeichert werden kann, sowie über einen Komparator, der ein Signal erzeugen kann, wenn die gemessene Temperatur die in diesem zweiten Register gespeicherte überschreitet. Um die Warnung erst wieder auszulösen, wenn die gemessene Temperatur einen bestimmten Wert unterschreitet, ermöglicht ein drittes Register die Speicherung eines Werts für die Temperatur Histéresis.
Die Konfiguration des LM75-Betriebs wird in einem vierten Register gespeichert, mit dem die Bedingungen, unter denen die Warnung generiert wird, die Art der Auslösung dieses Warnsignals (Unterbrechungsmodus oder Vergleichsmodus) sowie die Aktivierung des Geräts (Modus) festgelegt werden . normaler Betrieb oder geringer Verbrauch) unter anderem.
Technische Spezifikationen und Implementierung des LM75
Der Temperaturbereich, den der LM75 messen kann, reicht von –55 °C bis +125 °C und die numerische Auflösung beträgt 0.125 °C, obwohl die Genauigkeit im besten Fall nur ±2 °C beträgt, wenn die Temperatur zwischen –25 °C liegt °C und +100 °C und eine Genauigkeit von ±3 °C bei extremsten Temperaturen zwischen −55 °C und +125 °C.
Die Implementierung (Hardware) des LM75 in eine Schaltung ist sehr einfach, es werden nicht mehr Komponenten als die Widerstände benötigt Klimmzug Restaurants Bus I2C und kann mit einer Spannung zwischen 2,8 V und 5,5 V betrieben werden Bus I2C Durch Konfiguration der Adresse mit den drei Pins A75, A0 und A1 auf High- oder Low-Pegel, wie in diesen Fällen üblich, können bis zu acht LM2-Thermometer angeordnet werden.
Andererseits ist die Verwendung des LM75 als Sonde aufgrund der Verpackung, in der er präsentiert wird, unangenehm. TSSOP (TSSOP8) O SOIC (SO8) und wird normalerweise zur Messung der Umgebungstemperatur oder zur Messung der Temperatur von Komponenten verwendet, die in der Umgebung des Geräts angeordnet sind PCB in dem sich das LM75-Thermometer befindet.
Beim Start ist der LM75 so konfiguriert, dass er eine maximale Temperatur von +80 °C erkennt, eine Temperatur von Histéresis +75 °C und der Komparator-Betriebsmodus, also der Modus, der den Betrieb eines Thermostats nachahmt: Er aktiviert die Warnung bei Erreichen der Maximaltemperatur und erst bei Unterschreiten der Maximaltemperatur. Histéresis Erstellt den Hinweis neu.
Nutzung des LM75 von einem Mikrocontroller über den I2C-Bus
Dank der Verwendung von Bus I2C Die Bedienung des LM75 ist sehr einfach: Greifen Sie einfach auf die Adresse zu, die er am Bus einnimmt, um die Konfiguration zu speichern oder auszulesen und den Wert der gemessenen Temperatur zu erhalten.
Die Adresse I2C Die Basisadresse des LM75 ist 0B01001XXX und wird, wie oben erläutert, durch die letzten drei Adressbits ergänzt, die per Hardware mit den Pins A0, A1 und A2 auf High (Wert Eins) oder Low (Wert Null) gesetzt werden.
Das LM75 als Thermometer
Das Register, das die zuletzt gemessene Temperatur (TEMP) speichert, befindet sich an der Adresse 0x00, das Konfigurationsregister (CONF) befindet sich an der Adresse 0x01, das Register, das die Temperatur speichert Histéresis an der Adresse 0x02 und die Maximal- oder Übertemperatur (TOS) hat die Adresse 0x03. Bis auf die aktuelle Temperatur (TEMP) funktionieren alle als Lese- und Schreibfunktionen.
Unter Verwendung einiger Codebeispiele, die für entwickelt wurden Arduino (was fast zu einer universellen Referenz geworden ist) kann die Funktionsweise des LM75 weiter erläutert werden. Das grundlegendste nützliche Beispiel ist die Verwendung des LM75 als Thermometer, indem die Aufzeichnung der zuletzt gemessenen Temperatur abgelesen wird.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
#define DIRECCION_LM75 0B01001000 // Dirección del LM75 con A0, A1 y A2 a nivel bajo
#define TEMPERATURA_ACTUAL_LM75 0x00 // Registro que almacena la temperatura medida
//#define TIEMPO_CONVERSION_LM75 100 // El LM75 convierte la temperatura (AD) cada 100 ms así que el intervalo entre lecturas debe ser mayor.
#define TIEMPO_ENTRE_LECTURAS_DE_TEMPERATURA 3000 // Intervalo entre lecturas consecutivas de la temperatura en ms
#include <Wire.h>
int temperatura; // Valor de la temperatura actual cargado del LM75
void setup()
{
Serial.begin(9600); // Inicializar las comunicaciones serie (para mostrar en la consola el valor de la temperatura)
Wire.begin(); // Inicializar las comunicaciones I2C
}
void loop()
{
Wire.beginTransmission(DIRECCION_LM75); // Acceder al LM75 por su dirección en el bus I2C
Wire.write(TEMPERATURA_ACTUAL_LM75); // Solicitar la lectura del registro de la temperatura actual
Wire.endTransmission(); // Liberar el bus I2C
Wire.requestFrom(DIRECCION_LM75,2); // Pedir dos bytes (el valor del registro de la temperatura actual)
temperatura=(Wire.read()<<8)|Wire.read(); // Leer el primer byte, rotarlo 8 posiciones y añadir el valor del segundo byte
Wire.endTransmission(); // Liberar el bus I2C
Serial.println((float)temperatura/32/8,DEC); // Sólo son relevantes los 11 bits más significativos con una precisión de un octavo de grado (1/8 = 0.125 °C)
delay(TIEMPO_ENTRE_LECTURAS_DE_TEMPERATURA); // Esperar un poco antes de volver a leer la temperatura
}
|
Der Vorgang ist der übliche beim Arbeiten mit einem Gerät I2C:
- Fügen Sie die Bibliothek hinzu I2C zum Code mit
#include <Wire.h> - Initialisieren Sie die Bibliothek I2C Verwendung
Wire.begin(); - Greifen Sie über auf den Temperatursensor LM75 zu
Wire.beginTransmission(DIRECCION_LM75) - Senden Sie die Adresse der Registry, auf die zugegriffen wird
Wire.write(REGISTRO) - Lassen Sie die los Bus I2C mit
Wire.endTransmission() - Greifen Sie erneut auf LM75 zu
- Fordern Sie den Registrierungswert mit an
Wire.requestFrom(DIRECCION,CANTIDAD) - Überprüfen Sie, ob Daten mit empfangen wurden
Wire.available() - Lesen Sie den angeforderten Wert
Wire.read()(so oft wie Bytes es ausmachen) - Obwohl dies nicht unbedingt erforderlich ist, lassen Sie die Datei los, wenn Sie fertig sind Bus I2C
Zusätzlich zum üblichen Protokoll zum Abrufen oder Speichern von Informationen in den Geräteprotokollen mithilfe des Bus I2CUm die vom LM75 bereitgestellten Daten nutzen zu können, muss das Format berücksichtigt werden, in dem er die Temperatur intern darstellt.
Abrufen des in den LM75-Temperaturaufzeichnungen gespeicherten Werts
In Zeile 22 des Codes im vorherigen Beispiel können Sie sehen, wie die von den drei Temperaturregistern des LM75 gespeicherten Informationen geladen werden. Es verwendet zwei Bytes (16 Bits), von denen nur die 11 höchstwertigen Bits gültig sind. Zum Lesen der Temperatur als Ganzzahl (mit codiertem Vorzeichen). Zweierkomplement) wird das höchstwertige Byte zuerst in eine Variable geladen int de Arduino und es wird um 8 Bit nach links rotiert, so dass es im höchstwertigen Teil verbleibt int. Anschließend wird das zweite Byte gelesen und zur Variablen hinzugefügt. int mit einer ODER-Verknüpfung
Interpretation des belasteten Temperaturwertes des LM75
In Zeile 24 sehen Sie, wie der Temperaturwert zu interpretieren ist. Zunächst ist es notwendig, als Ganzzahl durch 32 zu dividieren (die relevanten 11 Bits zu drehen, ohne das Vorzeichen zu verlieren) und durch 8 zu dividieren, was die Anzahl der „Schritte“ ist, mit denen die Temperatur dargestellt wird (Oktaven eines Grads). um einen Wert vom Typ zu erhalten float mit den entsprechenden Dezimalstellen. Da Compiler (einschließlich der Werkzeugkette de Arduino) die ganzzahlige Division durch 32 optimieren, ist es nicht notwendig, das Vorzeichen beizubehalten und die Bits „manuell“ zu rotieren, da die Operation nicht (merklich) schneller ist.
Überprüfen Sie den Datenempfang vom I2C-Bus
Obwohl der vorherige Code ohne Probleme funktioniert, obwohl nicht überprüft wird, ob die vom Gerät angeforderten Daten angekommen sind. Bus I2C, ist es am orthodoxesten (und ratsamsten), zu warten, bis die Daten in der entsprechenden Anzahl eintreffen. Da die Übertragungsgeschwindigkeit und Fehlerresistenz mehr als ausreichend sind, findet man häufig Codes, bei denen die Daten einfach angefordert und ohne Wartezeit gelesen werden. Für die Beispiele ist es sinnvoll, dies auf diese Weise zu tun, da sie nicht von der Hauptabsicht ablenken. Für den Produktionscode empfiehlt es sich jedoch, so vorzugehen, wie im siebten Punkt der Liste des Kommunikationsprozesses vorgeschlagen I2C. Der Code im folgenden Beispiel hebt die empfohlenen Änderungen hervor, um den LM75 in der Nutzungsphase zu verwenden.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
#define DIRECCION_LM75 0B01001000 // Dirección del LM75 con A0, A1 y A2 a nivel bajo
#define TEMPERATURA_ACTUAL_LM75 0x00 // Registro que almacena la temperatura medida
//#define TIEMPO_CONVERSION_LM75 100 // El LM75 convierte la temperatura (AD) cada 100 ms así que el intervalo entre lecturas debe ser mayor.
#define TIEMPO_ENTRE_LECTURAS_DE_TEMPERATURA 3000 // Intervalo entre lecturas consecutivas de la temperatura en ms
#define TIMEOUT_I2C 30 // Esperar 30 ms antes de renunciar a leer el bus I2C
#include <Wire.h>
int temperatura; // Valor de la temperatura actual cargado del LM75
unsigned long cronometro_i2c; // Cronómetro para medir el tiempo de espera de la lectura del bus I2C (y cancelar la operación si se supera el máximo)
void setup()
{
Serial.begin(9600); // Inicializar las comunicaciones serie (para mostrar en la consola el valor de la temperatura)
Wire.begin(); // Inicializar las comunicaciones I2C
}
void loop()
{
Wire.beginTransmission(DIRECCION_LM75); // Acceder al LM75 por su dirección en el bus I2C
Wire.write(TEMPERATURA_ACTUAL_LM75); // Solicitar la lectura del registro de la temperatura actual
Wire.endTransmission(); // Liberar el bus I2C
Wire.requestFrom(DIRECCION_LM75,2); // Pedir dos bytes (el valor del registro de la temperatura actual)
cronometro_i2c=millis();
while(Wire.available()<2&&(unsigned long)(millis()–cronometro_i2c)>TIMEOUT_I2C); // Esperar a que lleguen dos bytes al bus I2C o pase el tiempo máximo para abandonar
if(Wire.available()==2) // Si han llegado dos bytes
{
temperatura=(Wire.read()<<8)|Wire.read(); // Leer el primer byte, rotarlo 8 posiciones y añadir el valor del segundo byte
}
Wire.endTransmission(); // Liberar el bus I2C
Serial.println((float)temperatura/32/8,DEC); // Sólo son relevantes los 11 bits más significativos con una precisión de un octavo de grado (1/8 = 0.125 °C)
delay(TIEMPO_ENTRE_LECTURAS_DE_TEMPERATURA); // Esperar un poco antes de volver a leer la temperatura
}
|
Konfigurieren Sie den Betrieb des LM75
Die grundlegendste Konfiguration des LM75 besteht aus der Festlegung der maximalen Temperatur zur Generierung der Warnung und der Histéresis, die bestimmt, wann sie deaktiviert wird und wiederholt werden kann. Um diese Werte zu konfigurieren, müssen Sie sie lediglich in den entsprechenden Registern speichern.
Wie die aktuelle Temperaturaufzeichnung, die maximale (Warn-)Temperatur und Histéresis Sie verwenden zwei Bytes, berücksichtigen aber im Gegensatz zum ersten nicht 11 Bit (ein Achtel Grad), sondern 9 (ein halbes Grad), sodass selbst bei der Speicherung eines kleineren Werts nur Intervalle dieser Auflösung berücksichtigt würden.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
|
#define DIRECCION_LM75 0B01001000 // Dirección del LM75 con A0, A1 y A2 a nivel bajo
#define TEMPERATURA_ACTUAL_LM75 0x00 // Registro que almacena la temperatura medida
#define TEMPERATURA_MAXIMA_LM75 0x03 // Registro que almacena la temperatura máxima (al superarla avisa cambiando el estado del pin OS) 80 °C al inicio
#define TEMPERATURA_HISTERESIS_LM75 0x02 // Registro que almacena la temperatura por debajo de la cual la máxima vuelve a generar un cambio en el pin OS (temperatura de histéresis) 75 °C al inicio
//#define TIEMPO_CONVERSION_LM75 100 // El LM75 convierte la temperatura (AD) cada 100 ms
#define TIEMPO_ENTRE_AVISOS_DE_TEMPERATURA 3000 // Intervalo entre avisos consecutivos de exceso de temperatura en ms
#define TIMEOUT_I2C 30 // Esperar 30 ms antes de renunciar a leer el bus I2C
#define TEMPERATURA_AVISO 32.5 // Avisar a los 32.5 °C (Solamente se consideran 9 bits, es decir, medios grados)
#define TEMPERATURA_HISTERESIS 31.0 // No volver a avisar (a los 32.5 °C) hasta que no se baje a los 31.0 °C
#define PIN_AVISO_LM75 2 // Pin de Arduino al que se conecta la salida OS del LM75
#include <Wire.h> // Cargar la librería de las comunicaciones I2C
int temperatura; // Valor de la temperatura actual cargado del LM75
unsigned long cronometro_i2c; // Cronómetro para medir el tiempo de espera de la lectura del bus I2C (y cancelar la operación si se supera el máximo)
unsigned long cronometro_avisos=0; // Cronómetro para controlar que se avise del exceso de temperatura a un intervalo máximo (como máximo cada TIEMPO_ENTRE_AVISOS_DE_TEMPERATURA)
void setup()
{
pinMode(PIN_AVISO_LM75,INPUT); // Usar como entrada el pin de Arduino al que se conecta la salida OS del LM75
Serial.begin(9600); // Inicializar las comunicaciones serie
Wire.begin(); // Inicializar las comunicaciones I2C
//Configurar la temperatura de aviso
Wire.beginTransmission(DIRECCION_LM75); // Iniciar la comunicación con el LM75
Wire.write(TEMPERATURA_MAXIMA_LM75); // Acceder al registro que almacena la temperatura máxima (temperatura de aviso)
Wire.write((byte)((int)(TEMPERATURA_AVISO*8.0)>>3)); // Desplazar 5 bits a la izquierda y 8 a la derecha
Wire.write((byte)((int)(TEMPERATURA_AVISO*8.0)<<5)); // Desplazar 5 bits a la izquierda
Wire.endTransmission(); // Liberar el bus I2C
//Configurar la temperatura de histéresis
Wire.beginTransmission(DIRECCION_LM75); // Iniciar la comunicación con el LM75
Wire.write(TEMPERATURA_HISTERESIS_LM75); // Acceder a la temperatura de histéresis
Wire.write((byte)((int)(TEMPERATURA_HISTERESIS*8.0)>>3)); // Desplazar 5 bits a la izquierda y 8 a la derecha
Wire.write((byte)((int)(TEMPERATURA_HISTERESIS*8.0)<<5)); // Desplazar 5 bits a la izquierda
Wire.endTransmission(); // Liberar el bus I2C
// El aviso se activará cuando la temperatura sea TEMPERATURA_AVISO o superior
// y no se desactivará hasta que sea TEMPERATURA_HISTERESIS o inferior
}
void loop()
{
if(!digitalRead(PIN_AVISO_LM75)) // Si la señal OS del LM75 está a nivel bajo (polaridad por defecto del aviso)
{
if((millis()–cronometro_avisos)>TIEMPO_ENTRE_AVISOS_DE_TEMPERATURA) // Si ha transcurrido el tiempo entre avisos (además de estar activa la señal)
{
cronometro_avisos=millis(); // Reiniciar el cronómetro de aviso de la temperatura
Wire.beginTransmission(DIRECCION_LM75); // Acceder al LM75 por su dirección en el bus I2C
Wire.write(TEMPERATURA_ACTUAL_LM75); // Solicitar la lectura del registro de la temperatura actual
Wire.endTransmission(); // Liberar el bus I2C
Wire.requestFrom(DIRECCION_LM75,2); // Pedir dos bytes (el valor del registro de la temperatura actual)
cronometro_i2c=millis(); // Iniciar el cronómetro que controla si ha pasado el tiempo máximo de espera de recepción de datos desde el bus I2C
while(Wire.available()<2&&(unsigned long)(millis()–cronometro_i2c)>TIMEOUT_I2C); // Esperar a que lleguen dos bytes al bus I2C o pase el tiempo máximo para abandonar
if(Wire.available()==2) // Si han llegado dos bytes
{
temperatura=(Wire.read()<< 8)|Wire.read(); // Leer el primer byte, rotarlo 8 posiciones y añadir el valor del segundo byte
Serial.println((float)temperatura/32/8,DEC); // Sólo son relevantes los 11 bits más significativos con una precisión de un octavo de grado (1/8 = 0.125 °C)
}
Wire.endTransmission(); // Liberar el bus I2C
}
}
}
|
Da im vorherigen Code nur die Konfiguration der mit der Warnung verbundenen Temperaturen geändert wurde, entspricht der restliche Vorgang der Standardkonfiguration.
In dieser Standardkonfiguration sind zwei Merkmale relevant: Erstens der Warnmodus, der standardmäßig als „Thermostatmodus“ bezeichnet wird und darin besteht, die Warnung zu aktivieren, wenn die maximale Temperatur (oder Warnung) erreicht ist, und sie erst dann zu deaktivieren, wenn sie niedriger ist Temperatur von Histéresis. Die Alternative ist der „Interrupt-Modus“, bei dem das Signal aktiviert wird, wenn es das Maximum überschreitet oder einen niedrigeren Wert als den des erreicht Histéresis und wird durch das Lesen eines beliebigen Datensatzes, normalerweise der aktuellen Temperatur, zurückgesetzt.
Das zweite Merkmal besteht darin, dass das Warnsignal auf einem niedrigen Pegel aktiviert wird, d. h. der OS-Pin ist auf einem hohen Pegel, bis die maximale Warntemperatur erreicht ist. Da die Polarität des Warnsignals (der Pegel, bei dem es aktiviert wird) konfigurierbar ist, reicht es in einigen einfachen Installationen aus, dieses Signal (Hardware) zu verwenden, um den LM75 auszunutzen, beispielsweise um einen Lüfter anzuschließen oder zu trennen, wenn das System ausgeschaltet ist eine bestimmte Temperatur erreicht.
Es ist auch möglich, den Betrieb des LM75 so zu konfigurieren, dass er nicht sofort nach Erreichen der Warntemperatur warnt, sondern erst nach mehreren Vorfällen. Dieses Verhalten ist sehr nützlich, wenn an der Temperaturgrenze gearbeitet wird oder diese sehr schnell schwankt. Der LM75 kann so konfiguriert werden, dass er nach ein-, zwei-, vier- oder sechsmaliger Überschreitung der Maximaltemperatur warnt.
Im Konfigurationsregister gibt es auch ein Bit, um den LM75 zu deaktivieren („ausschalten“) und in einen Niedrigverbrauchsmodus zu wechseln, der durch erneutes Ändern dieses Bits oder einfach beim Lesen des nächsten Registers verlassen wird.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
#define DIRECCION_LM75 0B01001000 // Dirección del LM75 con A0, A1 y A2 a nivel bajo
#define TEMPERATURA_ACTUAL_LM75 0x00 // Registro que almacena la temperatura medida
#define TEMPERATURA_MAXIMA_LM75 0x03 // Registro que almacena la temperatura máxima (al superarla avisa cambiando el estado del pin OS) 80 °C al inicio
#define TEMPERATURA_HISTERESIS_LM75 0x02 // Registro que almacena la temperatura por debajo de la cual la máxima vuelve a generar un cambio en el pin OS (temperatura de histéresis) 75 °C al inicio
#define CONFIGURACION_LM75 0x01 // Registro del LM75 que almacena la configuración. El valor por defecto es cero
#define ENCENDER_LM75 0B00000000 // Encender el LM75 almacenando este valor (OR el resto) en el registro de configuración
#define APAGAR_LM75 0B00000001 // Apagar el LM75 (modo de bajo consumo) almacenando el valoren el registro de configuración
#define AVISO_LM75_COMPARAR 0B00000000 // Activo cuando se supera la temperatura máxima inactivo cuando la temperatura es menor que la de histéresis (modo termostato)
#define AVISO_LM75_INTERRUPCION 0B00000010 // Activo cuando se supera la temperatura máxima. Se resetea al leer el valor. No se volverá a activar hasta que no se alcance (primero) la de histéresis
#define AVISAR_LM75_BAJO 0B00000000 // Establece el nivel bajo en el pin OS cuando se supere la temperatura máxima
#define AVISAR_LM75_ALTO 0B00000100 // Establece el nivel alto en el pin OS cuando se supere la temperatura máxima
#define AVISAR_LM75_A_1 0B00000000 // Avisar cuando se supere una vez la temperatura (con riesgo de que un error producido por ruido en la conversión lance un aviso incorrecto)
#define AVISAR_LM75_A_2 0B00001000 // Avisar de temperatura superada cuando se mida dos veces
#define AVISAR_LM75_A_4 0B00010000 // Avisar de temperatura superada cuando se mida cuatro veces
#define AVISAR_LM75_A_6 0B00011000 // Avisar de temperatura superada cuando se mida seis veces
//#define TIEMPO_CONVERSION_LM75 100 // El LM75 convierte la temperatura (AD) cada 100 ms
#define TIEMPO_ENTRE_LECTURAS_DE_TEMPERATURA 2000 // Intervalo entre lecturas de la temperatura en ms
#define TIMEOUT_I2C 30 // Esperar 30 ms antes de renunciar a leer el bus I2C
#define TEMPERATURA_AVISO 32.5 // Avisar a los 32.5 °C (Solamente se consideran 9 bits, es decir, medios grados)
#define TEMPERATURA_HISTERESIS 31.0 // No volver a avisar (a los 32.5 °C) hasta que no se baje a los 31.0 °C
#define PIN_AVISO_LM75 7 // Pin de Arduino al que se conecta la salida OS del LM75
#include <Wire.h> // Cargar la librería de las comunicaciones I2C
int temperatura; // Valor de la temperatura actual cargado del LM75
unsigned long cronometro_i2c; // Cronómetro para medir el tiempo de espera de la lectura del bus I2C (y cancelar la operación si se supera el máximo)
unsigned long cronometro_avisos=0; // Cronómetro para controlar que se avise del exceso de temperatura a un intervalo máximo (como máximo cada TIEMPO_ENTRE_AVISOS_DE_TEMPERATURA)
void setup()
{
pinMode(PIN_AVISO_LM75,INPUT); // Usar como entrada el pin de Arduino al que se conecta la salida OS del LM75
Serial.begin(9600); // Inicializar las comunicaciones serie
Wire.begin(); // Inicializar las comunicaciones I2C
// El aviso se activará, a nivel alto (AVISAR_LM75_ALTO), cuando la temperatura sea TEMPERATURA_AVISO o superior cuatro veces consecutivas (AVISAR_LM75_A_4, que vale 0B00010000)
// y no se desactivará hasta que sea TEMPERATURA_HISTERESIS o inferior
// Configurar la temperatura de aviso
Wire.beginTransmission(DIRECCION_LM75); // Iniciar la comunicación con el LM75
Wire.write(TEMPERATURA_MAXIMA_LM75); // Acceder al registro que almacena la temperatura máxima (temperatura de aviso)
Wire.write((byte)((int)(TEMPERATURA_AVISO*8.0)>>3)); // Desplazar 5 bits a la izquierda y 8 a la derecha
Wire.write((byte)((int)(TEMPERATURA_AVISO*8.0)<<5)); // Desplazar 5 bits a la izquierda
Wire.endTransmission(); // Liberar el bus I2C
// Configurar la temperatura de histéresis
Wire.beginTransmission(DIRECCION_LM75); // Iniciar la comunicación con el LM75
Wire.write(TEMPERATURA_HISTERESIS_LM75); // Acceder a la temperatura de histéresis
Wire.write((byte)((int)(TEMPERATURA_HISTERESIS*8.0)>>3)); // Desplazar 5 bits a la izquierda y 8 a la derecha
Wire.write((byte)((int)(TEMPERATURA_HISTERESIS*8.0)<<5)); // Desplazar 5 bits a la izquierda
Wire.endTransmission(); // Liberar el bus I2C
// Configurar el número de veces que debe superarse la temperatura para generar un aviso y la polaridad del aviso
Wire.beginTransmission(DIRECCION_LM75); // Iniciar la comunicación con el LM75
Wire.write(CONFIGURACION_LM75); // Acceder al registro de configuración
Wire.write(AVISAR_LM75_ALTO|AVISAR_LM75_A_4); // Componer la configuración con operaciones OR sobre los diferentes (bits) valores
Wire.endTransmission(); // Liberar el bus I2C
}
void loop()
{
if((millis()–cronometro_avisos)>TIEMPO_ENTRE_LECTURAS_DE_TEMPERATURA) // Si ha transcurrido el tiempo entre lecturas
{
cronometro_avisos=millis(); // Reiniciar el cronómetro de aviso de la temperatura
Wire.beginTransmission(DIRECCION_LM75); // Acceder al LM75 por su dirección en el bus I2C
Wire.write(TEMPERATURA_ACTUAL_LM75); // Solicitar la lectura del registro de la temperatura actual
Wire.endTransmission(); // Liberar el bus I2C
Wire.requestFrom(DIRECCION_LM75,2); // Pedir dos bytes (el valor del registro de la temperatura actual)
cronometro_i2c=millis(); // Iniciar el cronómetro que controla si ha pasado el tiempo máximo de espera de recepción de datos desde el bus I2C
while(Wire.available()<2&&(unsigned long)(millis()–cronometro_i2c)>TIMEOUT_I2C); // Esperar a que lleguen dos bytes al bus I2C o pase el tiempo máximo para abandonar
if(Wire.available()==2) // Si han llegado dos bytes
{
temperatura=(Wire.read()<<8)|Wire.read(); // Leer el primer byte, rotarlo 8 posiciones y añadir el valor del segundo byte
Serial.print(“Temperatura “);
if(digitalRead(PIN_AVISO_LM75)) // Si la señal OS del LM75 está activa (a nivel alto)
{
Serial.print(“demasiado alta”);
}
else
{
Serial.print(“correcta”);
}
Serial.print(” (“);
Serial.print((float)temperatura/32/8,DEC); // Sólo son relevantes los 11 bits más significativos con una precisión de un octavo de grado (1/8 = 0.125 °C)
Serial.println(“)”);
}
Wire.endTransmission(); // Liberar el bus I2C
}
}
|
Geben Sie Anmerkung