Senzor de temperatură I2C LM75
Principiul de funcționare
El IC LM75 este a Senzor de temperatură bandgap cu semiconductor din siliciu.
În semiconductori, bandă interzisă Este zona energetică a electronilor care nu poate fi mărită odată cu creșterea câmpului electric, deoarece nu există stări disponibile pentru a se mișca mai rapid. Acest bandă interzisă este inclusă între banda de valență (energie mai mică) și bandă de conducție (energie mai mare). Excitația termică (creșterea temperaturii, în scopurile care ne interesează) poate determina ca unii electroni să dobândească suficientă energie pentru a trece în bandă de conducție.
După cum sa explicat în articolul anterior despre măsurarea electronică a temperaturii, în metale, deși numărul purtătorilor nu depinde de temperatură (toți electronii sunt întotdeauna disponibili), mobilitatea acestora este afectată de temperatură, astfel încât rezistența metalelor crește cu temperatura datorită scăderii vitezei electronilor datorită cresterea lor agitatie termica și împrăștierea electronilor pe care îi produce.
În cazul semiconductorilor, datorită prezenței acestuia bandă interzisă Numărul de purtători depinde de temperatură (în funcție de Distribuția Fermi–Dirac) determinând creșterea conductibilității odată cu temperatura. La semiconductori, creșterea temperaturii produce o creștere a rezistenței, dar produce și o creștere (în continuare) a conductibilității.
L senzori de temperatură cu bandă interzisă cu semiconductor din siliciu, ca și cazul LM75, funcționează după acest principiu, permițând determinarea temperaturii prin cuantificarea influenței acesteia asupra tensiunii dintr-o diodă de siliciu.
Componente hardware LM75
LM75 are, de asemenea, un convertor analog-digital prin modulație Sigma-Delta care este responsabilă de obținerea valorii numerice (digitale) a temperaturii, valoare care este ulterior stocată (la fiecare 100 ms) într-unul dintre registrele sale din care poate fi citită prin magistrală. I2C.
Pe lângă registrul care conține temperatura măsurată, LM75 are un registru în care poate fi stocată o temperatură maximă precum și un comparator care este capabil să genereze un semnal dacă temperatura măsurată o depășește pe cea stocată în acest al doilea registru. Pentru a nu lansa din nou avertismentul până când temperatura măsurată scade sub un anumit nivel, un al treilea registru permite stocarea unei valori pentru temperatura de histerezis.
Configurația funcționării LM75 este stocată într-un al patrulea registru cu care se determină condițiile în care este generată avertizarea, modul de lansare a acestui semnal de avertizare (mod întrerupere sau mod comparație) precum și activarea dispozitivului (modul) .funcţionare normală sau consum redus) printre alţi parametri.
Specificațiile tehnice și implementarea LM75
Intervalul de temperaturi pe care LM75 este capabil să le măsoare variază de la -55 °C la +125 °C, iar rezoluția numerică este de 0.125 °C, deși precizia este de numai ±2 °C în cel mai bun caz, când temperatura este între − 25 °C și +100 °C și o precizie de ±3 °C la cele mai extreme temperaturi, între -55 °C și +125 °C.
Implementarea (hardware) a LM75 într-un circuit este foarte simplă, nu are nevoie de mai multe componente decât rezistențele trage del luați autobuzul I2C si poate fi alimentat cu o tensiune intre 2,8 V si 5,5 V. In acelasi luați autobuzul I2C Până la opt termometre LM75 pot fi aranjate prin configurarea adresei lor cu cei trei pini A0, A1 și A2 la nivel înalt sau scăzut, așa cum este de obicei în aceste cazuri.
Pe de altă parte, utilizarea LM75 ca sondă este incomodă din cauza pachetelor în care este prezentat, TSSOP (TSSOP8) Sau SEC (SO8) și este utilizat în mod normal pentru măsurarea temperaturii ambiante sau pentru măsurarea temperaturii componentelor dispuse în mediul PCB în care se află termometrul LM75.
La pornire, LM75 este configurat să detecteze o temperatură maximă de +80°C, o temperatură de histerezis de +75 °C și modul de funcționare al comparatorului, adică modul care emulează funcționarea unui termostat: activează avertizarea când se atinge temperatura maximă și numai dacă scade sub histerezis Regenerează notificarea.
Exploatarea LM75 de la un microcontroler prin magistrala I2C
Datorită utilizării luați autobuzul I2C Funcționarea LM75 este foarte simplă, doar accesați adresa pe care o ocupă pe magistrală pentru a stoca sau citi configurația și pentru a obține valoarea temperaturii măsurate.
Adresa I2C baza LM75 este 0B01001XXX și este completată, după cum s-a explicat mai sus, de ultimii trei biți de adresă care sunt setați de hardware cu pinii A0, A1 și A2 ridicat (valoarea unu) sau scăzut (valoarea zero).
LM75 ca termometru
Registrul care stochează ultima temperatură măsurată (TEMP) se află la adresa 0x00, registrul de configurare (CONF) este la adresa 0x01, registrul care stochează temperatura de histerezis la adresa 0x02 și temperatura maximă sau supratemperatura (TOS) are adresa 0x03. Cu excepția temperaturii curente (TEMP), toate funcționează ca citire și scriere.
Folosind câteva exemple de cod dezvoltate pentru Arduino (care a devenit aproape o referință universală) funcționarea LM75 poate fi clarificată în continuare. Cel mai elementar exemplu util este utilizarea LM75 ca termometru citind înregistrarea ultimei temperaturi măsurate.
|
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
}
|
Procesul este cel obișnuit atunci când lucrați cu un dispozitiv I2C:
- Adăugați biblioteca I2C la codul cu
#include <Wire.h> - Inițializați biblioteca I2C utilizând
Wire.begin(); - Accesați senzorul de temperatură LM75 prin
Wire.beginTransmission(DIRECCION_LM75) - Trimiteți adresa registrului accesat folosind
Wire.write(REGISTRO) - Eliberați luați autobuzul I2C cu
Wire.endTransmission() - Reaccesați LM75
- Solicitați valoarea de registry cu
Wire.requestFrom(DIRECCION,CANTIDAD) - Verificați dacă datele au fost primite folosind
Wire.available() - Citiți valoarea cerută
Wire.read()(de câte ori alcătuiesc octeții) - Deși nu este esențial, când ați terminat, eliberați luați autobuzul I2C
În plus față de protocolul obișnuit pentru obținerea sau stocarea informațiilor în jurnalele dispozitivului folosind luați autobuzul I2C, pentru a exploata datele pe care le furnizează LM75, este necesar să se țină cont de formatul în care acesta reprezintă intern temperatura.
Obținerea valorii stocate în înregistrările de temperatură LM75
Pe linia 22 a codului din exemplul anterior puteți vedea cum să încărcați informațiile stocate de cele trei registre de temperatură ale LM75. Utilizează doi octeți (16 biți) dintre care doar cei 11 biți cei mai semnificativi sunt validi. Pentru a citi temperatura ca un număr întreg (cu semnul codificat în complementul a doi) cel mai semnificativ octet este încărcat mai întâi într-o variabilă int de Arduino și este rotit cu 8 biți la stânga, lăsându-l în cea mai semnificativă parte a int. Al doilea octet este apoi citit și adăugat la variabilă. int cu o operație SAU
Interpretarea valorii temperaturii încărcate a LM75
În rândul 24 puteți vedea cum să interpretați valoarea temperaturii. În primul rând, este necesar să împărțiți la 32 ca număr întreg (rotiți cei 11 biți relevanți fără a pierde semnul) și împărțiți la 8, care este numărul de „pași” cu care este reprezentată temperatura (octave de grad) pentru a obține o valoare de tip float cu zecimale corespunzătoare. Deoarece compilatorii (inclusiv toolchain de Arduino) optimizați diviziunea întregului cu 32, nu este necesar să păstrați semnul și să rotiți „manual” biții, deoarece operația nu este (apreciabil) mai rapidă.
Verificați recepția datelor de la magistrala I2C
Deși codul anterior va funcționa fără probleme, în ciuda faptului că nu se verifică dacă datele solicitate de dispozitiv au ajuns. luați autobuzul I2C, cel mai ortodox (și recomandabil) este să așteptați ca datele să ajungă în numărul corespunzător. Deoarece viteza de transmisie și rezistența la erori sunt mai mult decât suficiente, este obișnuit să găsiți cod în care datele sunt pur și simplu solicitate și citite fără așteptare. Pentru exemple, este util să procedați astfel, deoarece nu distrage atenția de la intenția principală, dar pentru codul de producție este recomandabil să o faceți așa cum este sugerat în al șaptelea punct al listei procesului de comunicare. I2C. Codul din exemplul următor evidențiază modificările recomandate pentru utilizarea LM75 în faza de exploatare.
|
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
}
|
Configurați funcționarea LM75
Cea mai de bază configurație a LM75 constă în stabilirea temperaturii maxime pentru a genera avertismentul și histerezis, care va determina când este dezactivat și poate fi repetat. Pentru a configura aceste valori, trebuie doar să le stocați în registrele corespunzătoare.
La fel ca înregistrarea actuală a temperaturii, temperatura maximă (avertizare) și histerezis Ei folosesc doi octeți, dar spre deosebire de primul nu iau în considerare 11 biți (o optime de grad) ci 9 (jumătate de grad) astfel încât, chiar dacă ar fi stocată o valoare mai mică, ar fi luate în considerare doar intervalele din această rezoluție.
|
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
}
}
}
|
Întrucât în codul anterior se modifică doar configurația temperaturilor aferente avertismentului, restul operațiunii corespunde configurației implicite.
În această configurație implicită există două caracteristici care sunt relevante, în primul rând modul de avertizare, implicit ceea ce se numește „mod termostat” care constă în activarea avertismentului atunci când temperatura maximă (sau avertismentul) este atinsă și nu dezactivarea acestuia până la coborâre la valoarea maximă. temperatura de histerezis. Alternativa este „modul de întrerupere”, în care semnalul este activat atunci când depășește maximul sau când atinge o valoare mai mică decât cea a histerezis și se resetează citind orice înregistrare, în mod normal temperatura curentă.
A doua caracteristică este că semnalul de avertizare este activat la un nivel scăzut, adică pinul OS este la un nivel ridicat până când se atinge temperatura maximă de avertizare. Deoarece polaritatea semnalului de avertizare (nivelul la care este activat) este configurabilă, în unele instalații simple va fi suficient să folosiți acest semnal (hardware) pentru a exploata LM75, de exemplu, conectarea sau deconectarea unui ventilator atunci când sistemul este instalat. atinge o anumită temperatură.
De asemenea, este posibil să configurați funcționarea LM75 astfel încât să nu avertizeze imediat după atingerea temperaturii de avertizare ci să o facă după mai multe incidente. Acest comportament este foarte util atunci când se lucrează la limita de temperatură sau când variază foarte repede. LM75 poate fi configurat să avertizeze după depășirea temperaturii maxime de una, două, patru sau șase ori.
În registrul de configurare există și un bit pentru a dezactiva („oprire”) LM75 și a intra într-un mod de consum redus, din care se iese schimbând din nou acest bit sau pur și simplu la citirea următorului registru.
|
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
}
}
|
Posteaza un comentariu