I2C hőmérséklet érzékelő LM75
Működési elve
El IC Az LM75 egy szilícium félvezető bandgap hőmérséklet érzékelő.
A félvezetőkben a tiltott zenekar Ez az elektronok energiazónája, amely nem növelhető az elektromos tér növekedésével, mivel nincsenek olyan állapotok, amelyek gyorsabban mozognának. Ez tiltott zenekar között szerepel vegyértéksáv (alacsonyabb energia) és a vezető szalag (nagyobb energia). A termikus gerjesztés (a hőmérséklet emelkedése az általunk érdekelt célokra) arra késztetheti az elektronokat, hogy elegendő energiát szerezzenek ahhoz, hogy a vezető szalag.
Amint azt az előző cikkben ismertettük elektronikus hőmérsékletmérés, fémekben, bár a hordozók száma nem függ a hőmérséklettől (mindig minden elektron rendelkezésre áll), mobilitásukat a hőmérséklet befolyásolja, így a fémekben az ellenállás a hőmérséklettel együtt nő az elektronok sebességének csökkenése miatt. az ő növekedésük termikus keverés és az általa előállított elektronok szórása.
Félvezetők esetében ennek megléte miatt tiltott zenekar A hordozók száma a hőmérséklettől függ (attól függően Fermi–Dirac eloszlás), ami a vezetőképesség növekedését okozza a hőmérséklettel. A félvezetőkben a hőmérséklet növekedése az ellenállás növekedését, de a vezetőképesség (további) növekedését is eredményezi.
sok szilícium félvezető sávszélességű hőmérséklet-érzékelők, akárcsak az LM75 esetében, ezen elv szerint működnek, lehetővé téve a hőmérséklet meghatározását a szilíciumdióda feszültségére gyakorolt hatásának számszerűsítésével.
LM75 hardverkomponensek
Az LM75-ben is van a analóg-digitális átalakító Sigma-Delta modulációval amely a hőmérséklet numerikus (digitális) értékének megszerzéséért felelős, amely értéket utólag (100 ms-onként) eltárol az egyik regiszterében, amelyből a buszon keresztül kiolvasható. I2C.
A mért hőmérsékletet tartalmazó regiszteren kívül az LM75 rendelkezik egy regiszterrel, amelyben egy maximális hőmérséklet tárolható, valamint egy komparátorral, amely képes jelet generálni, ha a mért hőmérséklet meghaladja a második regiszterben tárolt értéket. Annak érdekében, hogy a figyelmeztetés ne induljon újra, amíg a mért hőmérséklet egy bizonyos szint alá nem csökken, egy harmadik regiszter lehetővé teszi a hőmérséklet értékének tárolását. hiszterézis.
Az LM75 működésének konfigurációja egy negyedik regiszterben kerül tárolásra, amely meghatározza a figyelmeztetés generálásának feltételeit, a figyelmeztető jelzés indításának módját (megszakítási mód vagy összehasonlító mód), valamint az eszköz aktiválását (üzemmód). . normál működés vagy alacsony fogyasztás) egyéb paraméterek mellett.
Az LM75 műszaki leírása és kivitelezése
Az LM75 mérésére alkalmas hőmérséklettartomány -55°C és +125°C között változik, a numerikus felbontás pedig 0.125°C, bár a pontosság a legjobb esetben is csak ±2°C, ha a hőmérséklet - között van. 25 °C és +100 °C, valamint ±3 °C pontosság a legszélsőségesebb hőmérsékleten, -55 °C és +125 °C között.
Az LM75 megvalósítása (hardvere) egy áramkörben nagyon egyszerű, nem igényel több komponenst, mint az ellenállások felhúz del busz I2C és 2,8 V és 5,5 V közötti feszültséggel táplálható. Ugyanebben busz I2C Akár nyolc LM75 hőmérő is elrendezhető, ha a címüket a három A0, A1 és A2 érintkezővel magas vagy alacsony szinten konfigurálják, ahogy az ilyen esetekben szokásos.
Másrészt az LM75 szondaként való használata kényelmetlen a csomagolás miatt, amelyben bemutatják, TSSOP (TSSOP8) o SEC (SO8), és általában a környezeti hőmérséklet mérésére vagy a berendezés környezetében elhelyezett alkatrészek hőmérsékletének mérésére használják. PCB amelyben az LM75 hőmérő található.
Indításkor az LM75 úgy van beállítva, hogy +80°C-os maximális hőmérsékletet érzékeljen. hiszterézis +75 °C és a komparátor üzemmód, azaz a termosztát működését emuláló üzemmód: a maximális hőmérséklet elérésekor aktiválja a figyelmeztetést, és csak akkor, ha az a hőmérséklet alá esik. hiszterézis Újragenerálja az értesítést.
Az LM75 kiaknázása mikrokontrollerről az I2C buszon keresztül
A használatának köszönhetően busz I2C Az LM75 működése nagyon egyszerű, csak a buszon elfoglalt címhez kell hozzáférni a konfiguráció tárolásához vagy leolvasásához és a mért hőmérséklet értékének lekéréséhez.
A cím I2C Az LM75 alapja 0B01001XXX, és a fentiek szerint kiegészül az utolsó három címbittel, amelyeket hardver állít be magas (egyes érték) vagy alacsony (nulla érték) A0, A1 és A2 lábakkal.
Az LM75 mint hőmérő
Az utoljára mért hőmérsékletet tároló regiszter (TEMP) a 0x00 címen, a konfigurációs regiszter (CONF) a 0x01 címen található, az a regiszter, amely a hőmérsékletet tárolja. hiszterézis a 0x02 címen, és a maximális vagy túlmelegedés (TOS) címe 0x03. Az aktuális hőmérséklet (TEMP) kivételével mindegyik olvasási és írási funkcióként működik.
Néhány kódpélda felhasználásával, amelyhez fejlesztették ki Arduino (ami szinte univerzális referenciává vált) az LM75 működése tovább tisztázható. A legalapvetőbb hasznos példa az LM75 hőmérőként történő használata az utoljára mért hőmérséklet rekordjának leolvasásával.
|
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
}
|
A folyamat a szokásos, ha egy eszközzel dolgozik I2C:
- Adja hozzá a könyvtárat I2C a kódhoz
#include <Wire.h> - Inicializálja a könyvtárat I2C használatával
Wire.begin(); - Használja az LM75 hőmérséklet-érzékelőt
Wire.beginTransmission(DIRECCION_LM75) - Küldje el a segítségével elért rendszerleíró adatbázis címét
Wire.write(REGISTRO) - Engedje el a busz I2C a
Wire.endTransmission() - Hozzáférés újra az LM75-höz
- Kérje le a rendszerleíró adatbázis értékét a
Wire.requestFrom(DIRECCION,CANTIDAD) - Ellenőrizze, hogy az adatok érkeztek-e a használatával
Wire.available() - Olvassa el a kért értéket
Wire.read()(annyiszor, ahány bájt teszi ki) - Bár ez nem elengedhetetlen, ha végzett, engedje el a busz I2C
A szokásos protokollon túlmenően az eszközök naplóiban történő információszerzéshez vagy tároláshoz a busz I2C, az LM75 által szolgáltatott adatok kihasználásához figyelembe kell venni azt a formátumot, amelyben a belső hőmérsékletet reprezentálja.
Az LM75 hőmérsékleti rekordokban tárolt érték lekérése
Az előző példa kódjának 22. sorában láthatja, hogyan lehet betölteni az LM75 három hőmérsékletregisztere által tárolt információkat. Két bájtot (16 bitet) használ, amelyek közül csak a 11 legjelentősebb bit érvényes. A hőmérséklet egész számként történő olvasásához (kódolt előjellel kettő komplementere) a legjelentősebb bájt kerül először egy változóba int de Arduino és 8 bittel balra van elforgatva, így a legjelentősebb részében marad int. A második bájt ezután beolvasásra kerül és hozzáadódik a változóhoz. int VAGY művelettel
Az LM75 terhelt hőmérsékleti értékének értelmezése
A 24. sorban láthatja, hogyan kell értelmezni a hőmérsékleti értéket. Először is el kell osztani 32-vel egész számként (a vonatkozó 11 bitet el kell forgatni az előjel elvesztése nélkül) és osztani 8-cal, ami a hőmérséklet ábrázolásának „lépéseinek” száma (egy fok oktávja) típusú érték megszerzéséhez float a megfelelő tizedesjegyekkel. Mivel a fordítók (beleértve a toolchain de Arduino) optimalizálja az egész osztást 32-vel, nem szükséges megőrizni az előjelet és "kézi" forgatni a biteket, mivel a művelet nem (érzően) gyorsabb.
Ellenőrizze az adatvételt az I2C buszról
Bár az előző kód annak ellenére működik probléma nélkül, hogy nem ellenőrzi, hogy megérkeztek-e a készülék által kért adatok. busz I2C, a legortodoxabb (és tanácsosabb) megvárni, amíg az adatok megfelelő számban érkeznek. Mivel az átviteli sebesség és a hibákkal szembeni ellenállás több mint elegendő, gyakran találunk olyan kódot, amelyben az adatokat egyszerűen lekérjük, és várakozás nélkül kiolvassuk. A példáknál célszerű ezt így megtenni, mivel nem vonják el a figyelmet a fő szándékról, de a gyártási kódnál célszerű ezt a kommunikációs folyamat lista hetedik pontjában javasolt módon megtenni. I2C. A következő példa kódja kiemeli az LM75 használatához javasolt változtatásokat a kiaknázási fázisban.
|
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
}
|
Konfigurálja az LM75 működését
Az LM75 legalapvetőbb konfigurációja a maximális hőmérséklet beállításából áll a figyelmeztetés generálásához és a hiszterézis, amely meghatározza, hogy mikor van deaktiválva, és megismételhető. Ezen értékek konfigurálásához csak el kell tárolnia őket a megfelelő regiszterekben.
Az aktuális hőmérsékleti rekordhoz hasonlóan a maximális (figyelmeztető) hőmérséklet ill hiszterézis Két bájtot használnak, de az elsőtől eltérően nem 11 bitet (egy nyolcad fokot), hanem 9-et (fél fokot) vesznek figyelembe, így kisebb érték tárolása esetén is csak ennek a felbontásnak az intervallumait veszik figyelembe.
|
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
}
}
}
|
Mivel az előző kódban csak a figyelmeztetéssel kapcsolatos hőmérsékletek konfigurációja módosul, a művelet többi része az alapértelmezett konfigurációnak felel meg.
Ebben az alapértelmezett konfigurációban két fontos jellemző van, először is a figyelmeztetési mód, alapértelmezés szerint az úgynevezett "termosztát üzemmód", amely abból áll, hogy a maximális hőmérséklet (vagy figyelmeztetés) elérésekor aktiválja a figyelmeztetést, és nem kapcsolja ki, amíg a hőmérséklet le nem süllyed. hőmérséklete hiszterézis. Az alternatíva a "megszakítási mód", amelyben a jel akkor aktiválódik, ha meghaladja a maximumot, vagy ha a jel értéke alacsonyabb, mint a hiszterézis és minden rekord, általában az aktuális hőmérséklet leolvasásával visszaáll.
A második jellemző, hogy a figyelmeztető jelzés alacsony szinten aktiválódik, vagyis az OS érintkezője magas szinten van a maximális figyelmeztető hőmérséklet eléréséig. Mivel a figyelmeztető jel polaritása (az aktiválási szint) konfigurálható, néhány egyszerű telepítésnél elegendő ezt a jelet (hardvert) használni az LM75 kihasználásához, például ventilátor csatlakoztatásához vagy leválasztásához, amikor a rendszer elér egy bizonyos hőmérsékletet.
Lehetőség van arra is, hogy az LM75 működése úgy konfigurálható legyen, hogy ne azonnal a figyelmeztetési hőmérséklet elérése után, hanem többszöri incidens után jelezzen. Ez a viselkedés nagyon hasznos, ha a hőmérsékleti határértéken dolgozik, vagy ha az nagyon gyorsan változik. Az LM75 konfigurálható úgy, hogy figyelmeztesse a maximális hőmérséklet egy, kétszer, négy vagy hatszori túllépése után.
A konfigurációs regiszterben van még egy bit az LM75 deaktiválására ("kikapcsolására") és alacsony fogyasztású módba lépésre, amelyből a bit újbóli megváltoztatásával vagy egyszerűen a következő regiszter beolvasásával lehet kilépni.
|
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
}
}
|
Hozzászólás Comment