I2C temperaturni senzor LM75
Načelo delovanja
El IC LM75 je a silicijev polprevodniški temperaturni senzor pasovnega razmika.
V polprevodnikih je prepovedan bend To je energijsko območje elektronov, ki ga ni mogoče povečati s povečanjem električnega polja, saj ni razpoložljivih stanj za hitrejše premikanje. to prepovedan bend je vključen med valenčni pas (nižja energija) in prevodni pas (višja energija). Toplotno vzbujanje (zvišanje temperature za namene, ki nas zanimajo) lahko povzroči, da nekateri elektroni pridobijo dovolj energije, da preidejo v prevodni pas.
Kot je razloženo v prejšnjem članku o elektronsko merjenje temperature, v kovinah, čeprav število nosilcev ni odvisno od temperature (vsi elektroni so vedno na voljo), pa na njihovo mobilnost vpliva temperatura, tako da upor v kovinah narašča s temperaturo zaradi upadanja hitrosti elektronov zaradi povečanje njihovega toplotno mešanje in sipanje elektronov, ki jih proizvaja.
Pri polprevodnikih zaradi prisotnosti te prepovedan bend Število nosilcev je odvisno od temperature (odvisno od Fermi–Diracova porazdelitev), zaradi česar se prevodnost povečuje s temperaturo. Pri polprevodnikih zvišanje temperature povzroči povečanje upora, vendar povzroči (nadaljnje) povečanje prevodnosti.
P silicijevi polprevodniški temperaturni senzorji pasovnega razmika, tako kot v primeru LM75, delujejo po tem principu in omogočajo določitev temperature s kvantificiranjem njenega vpliva na napetost v silicijevi diodi.
Komponente strojne opreme LM75
LM75 ima tudi a analogno-digitalni pretvornik s sigma-delta modulacijo ki je odgovoren za pridobitev numerične (digitalne) vrednosti temperature, vrednosti, ki se nato shrani (vsakih 100 ms) v enega od svojih registrov, iz katerega se lahko prebere preko vodila I2C.
Poleg registra, ki vsebuje izmerjeno temperaturo, ima LM75 register, v katerega je mogoče shraniti najvišjo temperaturo, ter primerjalnik, ki je sposoben generirati signal, če izmerjena temperatura presega temperaturo, shranjeno v tem drugem registru. Da se opozorilo ne sproži znova, dokler izmerjena temperatura ne pade pod določeno raven, tretji register omogoča shranjevanje vrednosti za temperaturo histereza.
Konfiguracija delovanja LM75 je shranjena v četrtem registru, s katerim se določijo pogoji, pod katerimi se generira opozorilo, način sprožitve tega opozorilnega signala (način prekinitve ali primerjalni način) kot tudi aktiviranje naprave (način). .normalno delovanje ali nizka poraba) med drugimi parametri.
Tehnične specifikacije in izvedba LM75
Razpon temperatur, ki jih lahko meri LM75, se giblje od −55 °C do +125 °C, numerična ločljivost pa je 0.125 °C, čeprav je natančnost le ±2 °C v najboljšem primeru, ko je temperatura med − 25 °C in +100 °C ter natančnost ±3 °C z najbolj ekstremnimi temperaturami, med −55 °C in +125 °C.
Izvedba (strojna oprema) LM75 v vezju je zelo preprosta, ne potrebuje več komponent kot uporov vlečenje od avtobus I2C in se lahko napaja z napetostjo med 2,8 V in 5,5 V. V istem avtobus I2C Do osem termometrov LM75 je mogoče urediti s konfiguracijo njihovega naslova s tremi nožicami A0, A1 in A2 na visoki ali nizki ravni, kot je običajno v teh primerih.
Po drugi strani pa je uporaba LM75 kot sonde neprijetna zaradi paketov, v katerih je predstavljen, TSSOP (TSSOP8) o SEC (SO8) in se običajno uporablja za merjenje temperature okolice ali za merjenje temperature komponent, nameščenih v okolju PCB v kateri se nahaja termometer LM75.
Ob zagonu je LM75 konfiguriran tako, da zazna najvišjo temperaturo +80 °C, temperaturo histereza +75 °C in primerjalni način delovanja, torej način, ki posnema delovanje termostata: aktivira opozorilo, ko je dosežena najvišja temperatura in le, če ta pade pod histereza Ponovno ustvari obvestilo.
Izkoriščanje LM75 iz mikrokontrolerja preko vodila I2C
Zahvaljujoč uporabi avtobus I2C Delovanje LM75 je zelo preprosto, samo dostopajte do naslova, ki ga zaseda na vodilu, da shranite ali preberete konfiguracijo in pridobite vrednost izmerjene temperature.
Naslov I2C osnova LM75 je 0B01001XXX in je dopolnjena, kot je pojasnjeno zgoraj, z zadnjimi tremi naslovnimi biti, ki jih nastavi strojna oprema z nožicami A0, A1 in A2 visoko (vrednost ena) ali nizko (vrednost nič).
LM75 kot termometer
Register, ki hrani zadnjo izmerjeno temperaturo (TEMP), se nahaja na naslovu 0x00, konfiguracijski register (CONF) je na naslovu 0x01, register, ki shranjuje temperaturo histereza na naslovu 0x02 in najvišja ali nadtemperatura (TOS) ima naslov 0x03. Razen trenutne temperature (TEMP) vsi delujejo kot branje in pisanje.
Z uporabo nekaj primerov kode, razvitih za Arduino (ki je postala skoraj univerzalna referenca) je mogoče delovanje LM75 dodatno pojasniti. Najosnovnejši uporaben primer je uporaba LM75 kot termometra z branjem zapisa zadnje izmerjene temperature.
|
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
}
|
Postopek je običajen pri delu z napravo I2C:
- Dodajte knjižnico I2C na kodo z
#include <Wire.h> - Inicializirajte knjižnico I2C uporabo
Wire.begin(); - Do temperaturnega senzorja LM75 dostopajte z uporabo
Wire.beginTransmission(DIRECCION_LM75) - Pošljite naslov registra, do katerega dostopate z uporabo
Wire.write(REGISTRO) - Sprostite avtobus I2C z
Wire.endTransmission() - Znova dostopajte do LM75
- Zahtevajte vrednost registra z
Wire.requestFrom(DIRECCION,CANTIDAD) - Preverite, ali so bili podatki prejeti z uporabo
Wire.available() - Preberite zahtevano vrednost
Wire.read()(tolikokrat, kolikor bajtov sestavlja) - Čeprav to ni nujno, ko končate, spustite avtobus I2C
Poleg običajnega protokola za pridobivanje ali shranjevanje informacij v dnevnikih naprave z uporabo avtobus I2C, je za izkoriščanje podatkov, ki jih zagotavlja LM75, treba upoštevati obliko, v kateri interno predstavlja temperaturo.
Pridobivanje vrednosti, shranjene v temperaturnih zapisih LM75
V vrstici 22 kode v prejšnjem primeru si lahko ogledate, kako naložiti informacije, shranjene v treh temperaturnih registrih LM75. Uporablja dva bajta (16 bitov), od katerih je veljavnih le 11 najpomembnejših bitov. Za branje temperature kot celega števila (z znakom, kodiranim v komplement dveh) najpomembnejši bajt se najprej naloži v spremenljivko int de Arduino in se zavrti za 8 bitov v levo, tako da ostane v najpomembnejšem delu int. Drugi bajt se nato prebere in doda spremenljivki. int z operacijo ALI
Razlaga naložene temperaturne vrednosti LM75
V vrstici 24 si lahko ogledate, kako interpretirati vrednost temperature. Najprej je treba deliti s 32 kot celo število (zasukati ustreznih 11 bitov brez izgube predznaka) in deliti z 8, kar je število "korakov", s katerimi je predstavljena temperatura (oktave stopinje) da dobimo vrednost tipa float z ustreznimi decimalkami. Ker prevajalniki (vključno z orodje de Arduino) optimizira celoštevilsko deljenje s 32, ni treba ohranjati predznaka in "ročno" vrteti bitov, saj operacija ni (opazno) hitrejša.
Preverite sprejem podatkov iz vodila I2C
Čeprav bo prejšnja koda delovala brez težav, kljub temu, da ni preverila, ali so prispeli podatki, ki jih zahteva naprava. avtobus I2C, najbolj ortodoksno (in priporočljivo) je počakati, da podatki prispejo v ustreznem številu. Ker sta hitrost prenosa in odpornost na napake več kot zadostni, je pogosto najti kodo, v kateri se podatki preprosto zahtevajo in preberejo brez čakanja. Za primere je koristno, da to storite na ta način, saj ne odvračajo od glavnega namena, za produkcijsko kodo pa je priporočljivo, da to storite, kot je predlagano v sedmi točki seznama komunikacijskega procesa. I2C. Koda v naslednjem primeru poudarja priporočene spremembe za uporabo LM75 v fazi izkoriščanja.
|
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
}
|
Konfigurirajte delovanje LM75
Najosnovnejša konfiguracija LM75 je sestavljena iz določitve najvišje temperature za generiranje opozorila in histereza, ki bo določil, kdaj je deaktiviran in ga je mogoče ponoviti. Če želite konfigurirati te vrednosti, jih morate samo shraniti v ustrezne registre.
Tako kot trenutni temperaturni rekord, najvišja (opozorilna) temperatura in histereza Uporabljajo dva bajta, vendar za razliko od prvega ne upoštevajo 11 bitov (osmina stopinje), ampak 9 (pol stopinje), tako da bi, tudi če bi bila shranjena manjša vrednost, upoštevani le intervali te ločljivosti.
|
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
}
}
}
|
Ker je v prejšnji kodi spremenjena samo konfiguracija temperatur, povezanih z opozorilom, preostali del operacije ustreza privzeti konfiguraciji.
V tej privzeti konfiguraciji sta pomembni dve značilnosti, najprej opozorilni način, privzeto tako imenovani "termostatski način", ki je sestavljen iz aktiviranja opozorila, ko je dosežena najvišja temperatura (ali opozorilo), in njegovega deaktiviranja šele, ko se zniža na temperatura od histereza. Alternativa je "prekinitveni način", v katerem se signal aktivira, ko preseže maksimum ali ko doseže vrednost, ki je nižja od histereza in se ponastavi z branjem katerega koli zapisa, običajno trenutne temperature.
Druga značilnost je, da se opozorilni signal aktivira na nizki ravni, to pomeni, da je OS pin na visoki ravni, dokler ni dosežena najvišja opozorilna temperatura. Ker je polarnost opozorilnega signala (raven, na kateri se aktivira) nastavljiva, bo v nekaterih preprostih namestitvah dovolj, da uporabite ta signal (strojna oprema) za izkoriščanje LM75, na primer priklop ali odklop ventilatorja, ko sistem doseže določeno temperaturo.
Možno je tudi konfigurirati delovanje LM75 tako, da ne opozori takoj, ko je dosežena opozorilna temperatura, ampak to stori po več incidentih. To vedenje je zelo uporabno pri delu pri temperaturni meji ali ko se zelo hitro spreminja. LM75 je mogoče konfigurirati tako, da opozori, ko enkrat, dvakrat, štiri ali šestkrat preseže najvišjo temperaturo.
V konfiguracijskem registru je tudi bit za deaktivacijo ("izklop") LM75 in vstop v način nizke porabe, ki se izstopi s ponovno spremembo tega bita ali preprosto ob branju naslednjega registra.
|
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
}
}
|
po Komentar