I2C lämpötila-anturi LM75
Toimintaperiaate
El IC LM75 on a piipuolijohdekaistan lämpötila-anturi.
Puolijohteissa kielletty bändi Se on elektronien energiavyöhyke, jota ei voida lisätä sähkökentän kasvaessa, koska käytettävissä ei ole tiloja, jotka voisivat liikkua nopeammin. Tämä kielletty bändi sisältyy väliin valenssinauha (pienempi energia) ja johtavuusnauha (korkeampi energia). Lämpöviritys (lämpötilan nousu meitä kiinnostaviin tarkoituksiin) voi saada jotkut elektronit hankkimaan tarpeeksi energiaa siirtyäkseen johtavuusnauha.
Kuten edellisessä artikkelissa kerrottiin elektroninen lämpötilan mittaus, metalleissa, vaikka kantoaaltojen määrä ei riipu lämpötilasta (kaikki elektronit ovat aina saatavilla), lämpötila vaikuttaa niiden liikkuvuuteen, joten metallien vastus kasvaa lämpötilan mukana elektronien nopeuden pienentymisen vuoksi. niiden lisääntyminen lämpösekoitus ja sen tuottamaa elektronien sirontaa.
Puolijohteiden tapauksessa tämän vuoksi kielletty bändi Kantajien määrä riippuu lämpötilasta (riippuen Fermi–Dirac-jakelu) aiheuttaa johtavuuden lisääntymisen lämpötilan mukana. Puolijohteissa lämpötilan nousu lisää resistanssia, mutta tuottaa myös (edelleen) johtavuuden kasvun.
Los piipuolijohdekaistan lämpötila-anturitLM75:n tapaan, toimivat tämän periaatteen mukaisesti, jolloin lämpötila voidaan määrittää kvantifioimalla sen vaikutus piidiodin jännitteeseen.
LM75 laitteistokomponentit
LM75:ssä on myös analogia-digitaalimuunnin Sigma-Delta-modulaatiolla joka vastaa lämpötilan numeerisen (digitaalisen) arvon saamisesta, arvo, joka tallennetaan myöhemmin (100 ms välein) johonkin sen rekistereistä, josta se voidaan lukea väylän kautta I2C.
Mitatun lämpötilan sisältävän rekisterin lisäksi LM75:ssä on rekisteri, johon voidaan tallentaa maksimilämpötila, sekä komparaattori, joka pystyy muodostamaan signaalin, jos mitattu lämpötila ylittää tähän toiseen rekisteriin tallennetun. Jotta varoitus ei käynnisty uudelleen ennen kuin mitattu lämpötila laskee tietyn tason alapuolelle, kolmas rekisteri mahdollistaa arvon tallentamisen lämpötilalle. hystereesi.
LM75:n toiminnan konfiguraatio tallennetaan neljänteen rekisteriin, jossa määritetään olosuhteet, joissa varoitus syntyy, tämän varoitussignaalin laukaisutapa (keskeytystila tai vertailutila) sekä laitteen aktivointi (tila) normaali toiminta tai alhainen kulutus) muiden parametrien joukossa.
LM75:n tekniset tiedot ja toteutus
Lämpötila-alue, jonka LM75 pystyy mittaamaan, vaihtelee välillä −55°C - +125°C ja numeerinen resoluutio on 0.125°C, vaikka tarkkuus on vain ±2°C parhaassa tapauksessa, kun lämpötila on välillä − 25 °C ja +100 °C ja tarkkuus ±3 °C äärimmäisissä lämpötiloissa, -55 °C - +125 °C.
LM75:n toteutus (laitteisto) piirissä on hyvin yksinkertainen, se ei vaadi enempää komponentteja kuin vastukset leuanveto ja bussi I2C ja sitä voidaan käyttää jännitteellä välillä 2,8 V - 5,5 V. Samassa bussi I2C Jopa kahdeksan LM75-lämpömittaria voidaan järjestää määrittämällä niiden osoitteet kolmella nastalla A0, A1 ja A2 korkealla tai matalalla tasolla, kuten näissä tapauksissa on tavallista.
Toisaalta LM75:n käyttö anturina on epämukavaa johtuen pakkauksista, joissa se esitetään, TSSOP (TSSOP8) Tai SEC (SO8) ja sitä käytetään tavallisesti mittaamaan ympäristön lämpötilaa tai mittaamaan laitteen ympäristöön sijoitettujen komponenttien lämpötilaa. PCB jossa LM75 lämpömittari sijaitsee.
Käynnistettäessä LM75 on konfiguroitu havaitsemaan +80°C:n maksimilämpötila. hystereesi +75 °C ja vertailutila, eli tila, joka emuloi termostaatin toimintaa: se aktivoi varoituksen, kun maksimilämpötila saavutetaan ja vain jos se laskee alle hystereesi Luo ilmoituksen uudelleen.
LM75:n hyödyntäminen mikro-ohjaimesta I2C-väylän kautta
Kiitos bussi I2C LM75:n käyttö on hyvin yksinkertaista, vain käytä sen väylässä olevaa osoitetta tallentaaksesi tai lukeaksesi konfiguraation ja saadaksesi mitatun lämpötilan arvon.
Osoite I2C LM75:n kanta on 0B01001XXX ja sitä täydennetään, kuten edellä selitettiin, kolmella viimeisellä osoitebitillä, jotka on asetettu laitteistolla nastoilla A0, A1 ja A2 korkealla (arvo yksi) tai matalalla (arvo nolla).
LM75 lämpömittarina
Rekisteri, joka tallentaa viimeksi mitatun lämpötilan (TEMP), sijaitsee osoitteessa 0x00, konfigurointirekisteri (CONF) on osoitteessa 0x01, rekisteri, joka tallentaa lämpötilan hystereesi osoitteessa 0x02 ja maksimi- tai ylilämpötilan (TOS) osoite on 0x03. Nykyistä lämpötilaa (TEMP) lukuun ottamatta ne kaikki toimivat luku- ja kirjoitusasuina.
Käyttämällä joitain koodiesimerkkejä, jotka on kehitetty varten Työläs (josta on tullut melkein yleinen referenssi) LM75:n toimintaa voidaan selventää edelleen. Yleisin hyödyllinen esimerkki on käyttää LM75:tä lämpömittarina lukemalla viimeisimmän mitatun lämpötilan tallenne.
|
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
}
|
Prosessi on tavallinen laitteen kanssa työskennellessä I2C:
- Lisää kirjasto I2C koodiin kanssa
#include <Wire.h> - Alusta kirjasto I2C käyttäen
Wire.begin(); - Pääset LM75-lämpötila-anturiin käyttämällä
Wire.beginTransmission(DIRECCION_LM75) - Lähetä sen rekisterin osoite, jota käytät
Wire.write(REGISTRO) - Vapauta bussi I2C kanssa
Wire.endTransmission() - Avaa uudelleen LM75
- Pyydä rekisteriarvoa käyttämällä
Wire.requestFrom(DIRECCION,CANTIDAD) - Varmista, että tiedot on vastaanotettu käyttämällä
Wire.available() - Lue pyydetty arvo
Wire.read()(niin monta kertaa kuin tavut muodostavat sen) - Vaikka se ei ole välttämätöntä, vapauta, kun olet valmis bussi I2C
Tavallisen protokollan lisäksi tietojen hankkimiseksi tai tallentamiseksi laitelokeihin käyttämällä bussi I2CLM75:n tarjoamien tietojen hyödyntämiseksi on otettava huomioon muoto, jossa se sisäisesti edustaa lämpötilaa.
LM75:n lämpötilatietueisiin tallennetun arvon saaminen
Edellisen esimerkin koodin riviltä 22 näet kuinka ladataan LM75:n kolmen lämpötilarekisterin tallentamat tiedot. Se käyttää kahta tavua (16 bittiä), joista vain 11 tärkeintä bittiä ovat kelvollisia. Lämpötilan lukeminen kokonaislukuna (merkki koodattuina kahden komplementti) merkitsevin tavu ladataan ensin muuttujaan int de Työläs ja sitä kierretään 8 bittiä vasemmalle, jolloin se jää tärkeimmälle osalle int. Toinen tavu luetaan ja lisätään muuttujaan. int TAI-operaation kanssa
LM75:n kuormitetun lämpötila-arvon tulkinta
Rivillä 24 näet kuinka lämpötila-arvo tulkitaan. Ensinnäkin on tarpeen jakaa 32:lla kokonaislukuna (kierrä asiaankuuluvat 11 bittiä menettämättä etumerkkiä) ja jakaa 8:lla, mikä on "askeleiden" lukumäärä, joilla lämpötila esitetään (asteen oktaavit) tyypin arvon saamiseksi float vastaavilla desimaaleilla. Koska kääntäjät (mukaan lukien työkaluketjun de Työläs) optimoida kokonaislukujako luvulla 32, etumerkkiä ei tarvitse säilyttää ja bittejä "manuaalisesti" kiertää, koska toiminto ei ole (huomattavasti) nopeampi.
Tarkista tiedon vastaanotto I2C-väylältä
Vaikka edellinen koodi toimii ilman ongelmia, vaikka ei ole varmistettu, ovatko laitteen pyytämät tiedot saapuneet. bussi I2C, ortodoksisin (ja suositeltavin) asia on odottaa, että tietoja saapuu oikea määrä. Koska siirtonopeus ja virhekestävyys ovat enemmän kuin riittävät, on tavallista löytää koodi, jossa tiedot yksinkertaisesti pyydetään ja luetaan odottamatta. Esimerkeissä on hyödyllistä tehdä se näin, koska ne eivät häiritse päätarkoitusta, mutta tuotantokoodin osalta on suositeltavaa tehdä se viestintäprosessin luettelon seitsemännessä kohdassa ehdotetulla tavalla. I2C. Seuraavan esimerkin koodi korostaa suositeltuja muutoksia LM75:n käyttöön hyväksikäyttövaiheessa.
|
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
}
|
Määritä LM75:n toiminta
LM75:n yksinkertaisin konfiguraatio koostuu enimmäislämpötilan määrittämisestä varoituksen ja varoituksen luomiseksi hystereesi, joka määrittää, milloin se poistetaan käytöstä ja voidaan toistaa. Voit määrittää nämä arvot vain tallentamalla ne vastaaviin rekistereihin.
Kuten nykyinen lämpötilaennätys, maksimi (varoitus) lämpötila ja hystereesi Ne käyttävät kahta tavua, mutta toisin kuin ensimmäinen, ne eivät ota huomioon 11 bittiä (asteen kahdeksasosa) vaan 9 (puoli astetta), joten vaikka pienempi arvo tallennettaisiin, vain tämän resoluution intervallit otettaisiin huomioon.
|
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
}
}
}
|
Koska edellisessä koodissa vain varoitukseen liittyvien lämpötilojen konfiguraatiota muutetaan, vastaa muu toiminta oletuskonfiguraatiota.
Tässä oletuskokoonpanossa on kaksi olennaista ominaisuutta, ensinnäkin varoitustila, oletusarvoisesti ns. "termostaattitila", joka sisältää varoituksen aktivoinnin, kun maksimilämpötila (tai varoitus) saavutetaan, eikä sitä deaktivoida ennen kuin se laskee lämpötilasta hystereesi. Vaihtoehtona on "keskeytystila", jossa signaali aktivoituu, kun se ylittää maksimin tai kun se saavuttaa arvon, joka on pienempi kuin hystereesi ja nollataan lukemalla mikä tahansa tietue, tavallisesti nykyinen lämpötila.
Toinen ominaisuus on, että varoitussignaali aktivoituu alhaisella tasolla, eli käyttöjärjestelmän nasta on korkealla tasolla, kunnes varoituslämpötila on saavutettu. Koska varoitussignaalin napaisuus (taso, jolla se aktivoituu) on määritettävissä, joissakin yksinkertaisissa asennuksissa riittää tämän signaalin (laitteiston) käyttäminen LM75:n hyödyntämiseen, esimerkiksi tuulettimen kytkemiseen tai irrotukseen, kun järjestelmä saavuttaa tietyn lämpötilan.
On myös mahdollista konfiguroida LM75:n toiminta siten, että se ei varoita heti varoituslämpötilan saavuttamisen jälkeen, vaan varoittaa useiden tapahtumien jälkeen. Tämä käyttäytyminen on erittäin hyödyllistä, kun työskennellään lämpötilarajalla tai kun se vaihtelee hyvin nopeasti. LM75 voidaan konfiguroida varoittamaan maksimilämpötilan ylittämisestä yksi, kaksi, neljä tai kuusi kertaa.
Konfigurointirekisterissä on myös vähän LM75:n deaktivointia ("sammuta") ja siirtymistä matalan kulutuksen tilaan, josta poistutaan muuttamalla tätä bittiä uudelleen tai yksinkertaisesti luettaessa seuraavaa rekisteriä.
|
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 Comment