I2C temperaturgivare LM75
Funktionsprincip
El IC LM75 är en kiselhalvledare bandgap temperatursensor.
I halvledare är förbjudet band Det är elektronernas energizon som inte kan ökas med en ökning av det elektriska fältet eftersom det inte finns några tillstånd tillgängliga för att röra sig snabbare. Detta förbjudet band ingår mellan valensbandet (lägre energi) och ledningsbandet (högre energi). Termisk excitation (ökningen i temperatur, för de syften vi är intresserade av) kan få vissa elektroner att förvärva tillräckligt med energi för att passera in i ledningsbandet.
Som förklarats i föregående artikel om elektronisk temperaturmätning, i metaller, även om antalet bärare inte beror på temperaturen (alla elektroner är alltid tillgängliga), påverkas deras rörlighet av temperaturen, så att motståndet i metaller ökar med temperaturen på grund av att elektronernas hastighet minskar p.g.a. ökningen av deras termisk omrörning och spridningen av elektroner som den producerar.
I fallet med halvledare, på grund av närvaron av detta förbjudet band Antalet bärare beror på temperaturen (beroende på Fermi–Dirac distribution) vilket gör att konduktiviteten ökar med temperaturen. I halvledare ger ökad temperatur en ökning av motståndet men ger också en (ytterligare) ökning av konduktiviteten.
mycket kiselhalvledare bandgap temperatursensorer, som är fallet med LM75, fungerar enligt denna princip, vilket gör att temperaturen kan bestämmas genom att kvantifiera dess inverkan på spänningen i en kiseldiod.
LM75 hårdvarukomponenter
LM75 har också en analog-digital omvandlare med Sigma-Delta modulering som ansvarar för att erhålla det numeriska (digitala) värdet på temperaturen, ett värde som sedan lagras (var 100:e ms) i ett av dess register från vilket det kan läsas via bussen I2C.
Utöver registret som innehåller den uppmätta temperaturen har LM75 ett register i vilket en maxtemperatur kan lagras samt en komparator som kan generera en signal om den uppmätta temperaturen överstiger den som lagras i detta andra register. För att inte utlösa varningen igen förrän den uppmätta temperaturen sjunker under en viss nivå, tillåter ett tredje register att lagra ett värde för temperaturen på hysteres.
Konfigurationen av LM75-operationen lagras i ett fjärde register med vilket villkoren under vilka varningen genereras, sättet att avge denna varningssignal (avbrottsläge eller jämförelseläge) samt aktiveringen av enheten (läge) bestäms normal drift eller låg förbrukning) bland andra parametrar.
Tekniska specifikationer och implementering av LM75
Temperaturintervallet som LM75 kan mäta varierar från −55 °C till +125 °C och den numeriska upplösningen är 0.125 °C även om precisionen endast är ±2 °C i bästa fall, när temperaturen är mellan − 25 °C och +100 °C och en noggrannhet på ±3 °C vid de mest extrema temperaturerna, mellan −55 °C och +125 °C.
Implementeringen (hårdvara) av LM75 i en krets är mycket enkel, den behöver inte fler komponenter än motstånden dra upp del Bussen I2C och kan drivas med en spänning mellan 2,8 V och 5,5 V. I samma Bussen I2C Upp till åtta LM75 termometrar kan ordnas genom att konfigurera deras adress med de tre stiften A0, A1 och A2 på hög eller låg nivå, vilket är vanligt i dessa fall.
Å andra sidan är användningen av LM75 som en sond obekväm på grund av förpackningarna som den presenteras i, TSSOP (TSSOP8) Eller SEC (SO8) och används normalt för att mäta omgivningstemperatur eller för att mäta temperaturen på komponenter som är anordnade i miljön på PCB där termometern LM75 sitter.
Vid start är LM75 konfigurerad att detektera en maximal temperatur på +80°C, en temperatur på hysteres på +75 °C och komparatorns driftläge, det vill säga läget som emulerar driften av en termostat: den aktiverar varningen när den maximala temperaturen uppnås och endast om den faller under hysteres Återskapar meddelandet.
Utnyttjande av LM75 från en mikrokontroller via I2C-bussen
Tack vare användningen av Bussen I2C Manövreringen av LM75 är mycket enkel, bara gå till adressen den upptar på bussen för att lagra eller läsa konfigurationen och för att få värdet på den uppmätta temperaturen.
Adressen I2C basen på LM75 är 0B01001XXX och kompletteras, som förklarats ovan, av de tre sista adressbitarna som ställs in av hårdvara med stift A0, A1 och A2 högt (värde ett) eller lågt (värde noll).
LM75 som termometer
Registret som lagrar den senast uppmätta temperaturen (TEMP) finns på adressen 0x00, konfigurationsregistret (CONF) finns på adressen 0x01, registret som lagrar temperaturen på hysteres vid adress 0x02 och max- eller övertemperatur (TOS) har adress 0x03. Förutom den aktuella temperaturen (TEMP) fungerar alla som läsning och skrivning.
Använder några kodexempel utvecklade för Arduino (vilket nästan har blivit en universell referens) LM75:s funktion kan förtydligas ytterligare. Det mest grundläggande användbara exemplet är att använda LM75 som en termometer genom att läsa posten för den senast uppmätta temperaturen.
|
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
}
|
Processen är den vanliga när man arbetar med en enhet I2C:
- Lägg till biblioteket I2C till koden med
#include <Wire.h> - Initiera biblioteket I2C med
Wire.begin(); - Åtkomst till LM75 temperatursensor via
Wire.beginTransmission(DIRECCION_LM75) - Skicka adressen till registret som nås med
Wire.write(REGISTRO) - Släpp Bussen I2C med
Wire.endTransmission() - Återåtkomst till LM75
- Begär registervärdet med
Wire.requestFrom(DIRECCION,CANTIDAD) - Verifiera att data har tagits emot med hjälp av
Wire.available() - Läs det begärda värdet
Wire.read()(så många gånger som bytes utgör det) - Även om det inte är nödvändigt, släpp när du är klar Bussen I2C
Förutom det vanliga protokollet för att erhålla eller lagra information i enhetsloggarna med hjälp av Bussen I2C, för att utnyttja data som LM75 tillhandahåller, är det nödvändigt att överväga formatet i vilket den internt representerar temperaturen.
Att erhålla värdet som lagrats i LM75 temperaturposter
På rad 22 i koden i föregående exempel kan du se hur du laddar informationen som lagras av de tre temperaturregistren på LM75. Den använder två byte (16 bitar) av vilka endast de 11 mest signifikanta bitarna är giltiga. För att läsa temperaturen som ett heltal (med tecknet inkodat tvås komplement) den mest signifikanta byten laddas först i en variabel int de Arduino och den roteras 8 bitar åt vänster, vilket lämnar den i den mest betydande delen av int. Den andra byten läses sedan och läggs till variabeln. int med en operation för operation
Tolkning av det laddade temperaturvärdet för LM75
På rad 24 kan du se hur man tolkar temperaturvärdet. Först och främst är det nödvändigt att dividera med 32 som ett heltal (rotera de relevanta 11 bitarna utan att förlora tecknet) och dividera med 8, vilket är antalet "steg" som temperaturen representeras med (oktaver av en grad) för att få ett typvärde float med motsvarande decimaler. Sedan kompilatorer (inklusive toolchain de Arduino) optimera heltalsdivisionen med 32, är det inte nödvändigt att bevara tecknet och "manuellt" rotera bitarna, eftersom operationen inte är (avsevärt) snabbare.
Verifiera datamottagningen från I2C-bussen
Även om den tidigare koden kommer att fungera utan problem trots att den inte har verifierat om data som begärts av enheten har anlänt. Bussen I2C, det mest ortodoxa (och tillrådliga) är att vänta på att data kommer fram i lämpligt antal. Eftersom överföringshastigheten och motståndet mot fel är mer än tillräcklig är det vanligt att hitta kod där data enkelt begärs och läses utan att vänta. För exemplen är det användbart att göra det på detta sätt eftersom de inte distraherar från huvudavsikten men för produktionskoden är det tillrådligt att göra det som föreslås i den sjunde punkten i listan över kommunikationsprocessen I2C. Koden i följande exempel belyser de rekommenderade ändringarna för att använda LM75 i exploateringsfasen.
|
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
}
|
Konfigurera driften av LM75
Den mest grundläggande konfigurationen av LM75 består av att fastställa den maximala temperaturen för att generera varningen och hysteres, som avgör när den är avaktiverad och kan upprepas. För att konfigurera dessa värden behöver du bara lagra dem i motsvarande register.
Liksom det aktuella temperaturrekordet, den maximala (varnings)temperaturen och hysteres De använder två byte men till skillnad från den första tar de inte hänsyn till 11 bitar (en åttondels grad) utan 9 (en halv grad) så att även om ett mindre värde skulle lagras, skulle endast intervall av denna upplösning beaktas.
|
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
}
}
}
|
Eftersom i föregående kod endast konfigurationen av temperaturerna relaterade till varningen ändras, motsvarar resten av operationen standardkonfigurationen.
I denna standardkonfiguration finns det två egenskaper som är relevanta, för det första varningsläget, som standard det som kallas "termostatläge" som består av att aktivera varningen när maxtemperaturen (eller varningen) uppnås och inte avaktivera den förrän lägre till temperatur på hysteres. Alternativet är "avbrottsläget", där signalen aktiveras när den överskrider maxvärdet eller när den når ett lägre värde än hysteres och återställs genom att avläsa valfri post, normalt den aktuella temperaturen.
Den andra egenskapen är att varningssignalen aktiveras på en låg nivå, det vill säga att OS-stiftet är på en hög nivå tills den maximala varningstemperaturen uppnås. Eftersom varningssignalens polaritet (nivån vid vilken den aktiveras) är konfigurerbar, kommer det i vissa enkla installationer att räcka att använda denna signal (hårdvara) för att utnyttja LM75, till exempel för att ansluta eller koppla bort en fläkt när systemet når en viss temperatur.
Det är också möjligt att konfigurera driften av LM75 så att den inte varnar direkt efter att varningstemperaturen uppnåtts utan gör det efter flera incidenter. Detta beteende är mycket användbart när man arbetar vid temperaturgränsen eller när det varierar mycket snabbt. LM75 kan konfigureras för att varna efter att ha överskridit maxtemperaturen en, två, fyra eller sex gånger.
I konfigurationsregistret finns även en bit för att avaktivera ("stänga av") LM75 och gå in i ett lågförbrukningsläge, vilket går ur genom att ändra denna bit igen eller helt enkelt vid läsning av nästa register.
|
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
}
}
|
Post kommentar