I2C temperatuuriandur LM75
Toimimispõhimõte
El IC LM75 on a räni pooljuht ribalaiuse temperatuuriandur.
Pooljuhtides on keelatud bänd See on elektronide energiatsoon, mida ei saa elektrivälja suurenemisega suurendada, kuna kiiremaks liikumiseks pole olekuid. See keelatud bänd sisaldub vahel valentsriba (madalam energia) ja juhtivusriba (kõrgem energia). Termiline ergutus (temperatuuri tõus meid huvitavatel eesmärkidel) võib panna mõned elektronid omandama piisavalt energiat, et siseneda juhtivusriba.
Nagu on selgitatud eelmises artiklis elektrooniline temperatuuri mõõtmine, metallides, kuigi kandjate arv ei sõltu temperatuurist (kõik elektronid on alati saadaval), mõjutab nende liikuvust temperatuur, nii et metallide takistus suureneb temperatuuri tõustes elektronide kiiruse vähenemise tõttu. nende suurenemine termiline segamine ja selle tekitatud elektronide hajumist.
Pooljuhtide puhul selle olemasolu tõttu keelatud bänd Kandjate arv sõltub temperatuurist (olenevalt Fermi-Dirac jaotus), mis põhjustab juhtivuse tõusu temperatuuri tõustes. Pooljuhtides suurendab temperatuuri tõus takistust, kuid suurendab ka juhtivust (edasi).
osa räni pooljuhtide ribalaiuse temperatuuriandurid, nagu LM75 puhul, töötavad selle põhimõtte kohaselt, võimaldades temperatuuri määrata kvantifitseerides selle mõju ränidioodi pingele.
LM75 riistvarakomponendid
LM75-l on ka a analoog-digitaalmuundur Sigma-Delta modulatsiooniga mis vastutab temperatuuri numbrilise (digitaalse) väärtuse saamise eest, mis salvestatakse hiljem (iga 100 ms järel) ühte selle registritest, millest saab lugeda siini kaudu. I2C.
Lisaks mõõdetud temperatuuri sisaldavale registrile on LM75-l register, kuhu saab salvestada maksimaalse temperatuuri, samuti komparaator, mis on võimeline genereerima signaali, kui mõõdetud temperatuur ületab selles teises registris salvestatut. Et hoiatust mitte uuesti käivitada enne, kui mõõdetud temperatuur langeb alla teatud taseme, võimaldab kolmas register salvestada temperatuuri väärtuse hüsterees.
LM75 töö konfiguratsioon salvestatakse neljandasse registrisse, milles määratakse hoiatuse genereerimise tingimused, hoiatussignaali käivitamise viis (katkestusrežiim või võrdlusrežiim) ning seadme aktiveerimine (režiim). . tavatöö või väike tarbimine) muude parameetrite hulgas.
LM75 tehnilised kirjeldused ja teostus
Temperatuuride vahemik, mida LM75 suudab mõõta, varieerub vahemikus –55 °C kuni +125 °C ja numbriline eraldusvõime on 0.125 °C, kuigi täpsus on parimal juhul vaid ±2 °C, kui temperatuur on vahemikus – 25 °C ja +100 °C ning täpsusega ±3 °C kõige äärmuslikumatel temperatuuridel, vahemikus –55 °C kuni +125 °C.
LM75 rakendamine (riistvara) vooluringis on väga lihtne, see ei vaja rohkem komponente kui takistid üles tõmbama kohta buss I2C ja saab toita pingega vahemikus 2,8 V kuni 5,5 V. Samas buss I2C Kuni kaheksa LM75 termomeetrit saab paigutada, konfigureerides nende aadressi kolme viiguga A0, A1 ja A2 kõrgel või madalal tasemel, nagu sellistel juhtudel tavaliselt.
Teisest küljest on LM75 kasutamine sondina ebamugav pakendite tõttu, milles see on esitatud, TSSOP (TSSOP8) Või SEC (SO8) ja seda kasutatakse tavaliselt ümbritseva õhu temperatuuri või seadme keskkonnas paiknevate komponentide temperatuuri mõõtmiseks. PCB milles asub termomeeter LM75.
Käivitamisel on LM75 konfigureeritud tuvastama maksimaalset temperatuuri +80°C, temperatuuri hüsterees +75 °C ja võrdlusrežiimi töörežiim, st režiim, mis emuleerib termostaadi tööd: see aktiveerib hoiatuse, kui maksimaalne temperatuur on saavutatud ja ainult siis, kui see langeb alla hüsterees Taastab teate.
LM75 kasutamine mikrokontrollerist I2C siini kaudu
Tänu buss I2C LM75 käsitsemine on väga lihtne, konfiguratsiooni salvestamiseks või lugemiseks ja mõõdetud temperatuuri väärtuse saamiseks lihtsalt pääsete juurde siinis olevale aadressile.
Aadress I2C LM75 baas on 0B01001XXX ja seda täiendavad, nagu eespool selgitatud, viimase kolme aadressibitiga, mis on seatud riistvara poolt viigudega A0, A1 ja A2 kõrge (väärtus üks) või madal (väärtus null).
LM75 kui termomeeter
Viimane mõõdetud temperatuuri (TEMP) salvestav register asub aadressil 0x00, konfiguratsiooniregister (CONF) on aadressil 0x01, register, mis salvestab temperatuuri hüsterees aadressil 0x02 ja maksimaalse või ületemperatuuri (TOS) aadress on 0x03. Välja arvatud praegune temperatuur (TEMP), toimivad need kõik lugemis- ja kirjutamisfunktsioonina.
Kasutades mõnda jaoks välja töötatud koodinäidet Arduino (millest on saanud peaaegu universaalne viide) saab LM75 toimimist veelgi selgitada. Kõige elementaarsem kasulik näide on kasutada LM75 termomeetrina, lugedes viimase mõõdetud temperatuuri rekordit.
|
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
}
|
Protsess on seadmega töötamisel tavaline I2C:
- Lisage raamatukogu I2C koodi juurde
#include <Wire.h> - Initsialiseerige raamatukogu I2C kasutamine
Wire.begin(); - Juurdepääs temperatuuriandurile LM75 kasutades
Wire.beginTransmission(DIRECCION_LM75) - Saatke selle registri aadress, millele juurdepääsu kasutasite
Wire.write(REGISTRO) - Vabastage buss I2C koos
Wire.endTransmission() - Juurdepääs uuesti LM75-le
- Taotlege registriväärtust kasutades
Wire.requestFrom(DIRECCION,CANTIDAD) - Kontrollige, kas andmed on vastu võetud kasutades
Wire.available() - Lugege nõutud väärtust
Wire.read()(nii mitu korda, kui baitid kokku moodustavad) - Kuigi see pole oluline, vabastage pärast lõpetamist buss I2C
Lisaks tavapärasele protokollile teabe hankimiseks või salvestamiseks seadme logidesse kasutades buss I2CLM75 pakutavate andmete kasutamiseks on vaja arvestada vorminguga, milles see sisemiselt temperatuuri esitab.
LM75 temperatuurikirjetesse salvestatud väärtuse saamine
Eelmise näite koodi real 22 näete, kuidas laadida LM75 kolme temperatuuriregistri poolt salvestatud teavet. See kasutab kahte baiti (16 bitti), millest kehtivad ainult 11 kõige olulisemat bitti. Temperatuuri lugemiseks täisarvuna (märgiga kodeeritud kahe täiend) kõige olulisem bait laaditakse kõigepealt muutujasse int de Arduino ja seda pööratakse 8 bitti vasakule, jättes selle kõige olulisemasse osasse int. Seejärel loetakse teine bait ja lisatakse muutujale. int operatsiooniga VÕI
LM75 laaditud temperatuuri väärtuse tõlgendamine
Real 24 näete, kuidas tõlgendada temperatuuri väärtust. Kõigepealt on vaja jagada 32-ga täisarvuna (pöörata vastavaid 11 bitti ilma märki kaotamata) ja jagada 8-ga, mis on "sammude" arv, millega temperatuuri esitatakse (kraadi oktaavid) tüübi väärtuse saamiseks float vastavate kümnendkohtadega. Kuna kompilaatorid (sh toolchain de Arduino) optimeerige täisarvude jagamist 32-ga, pole vaja märgi säilitamist ja bitte "käsitsi" pöörata, kuna toiming ei ole (tuntavalt) kiirem.
Kontrollige andmete vastuvõttu I2C siinilt
Kuigi eelmine kood töötab probleemideta vaatamata sellele, et ei kontrollita, kas seadme küsitud andmed on kohale jõudnud. buss I2C, kõige õigeusklikum (ja soovitavam) on oodata, kuni andmed saabuvad sobivas arvus. Kuna edastuskiirus ja veakindlus on enam kui piisavad, siis on tavaline, et leitakse kood, milles andmed lihtsalt küsitakse ja loetakse neid ootamata. Näidete puhul on kasulik seda teha nii, kuna need ei tõmba tähelepanu põhieesmärgilt kõrvale, kuid tootmiskoodi puhul on soovitatav seda teha nii, nagu on soovitatud suhtlusprotsessi loendi seitsmendas punktis I2C. Järgmises näites olev kood tõstab esile soovitatavad muudatused LM75 kasutamiseks kasutusfaasis.
|
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
}
|
Seadistage LM75 töö
LM75 kõige elementaarsem konfiguratsioon seisneb hoiatuse ja hoiatuse genereerimiseks maksimaalse temperatuuri määramises hüsterees, mis määrab, millal see desaktiveeritakse ja seda saab korrata. Nende väärtuste konfigureerimiseks peate need salvestama ainult vastavatesse registritesse.
Nagu praegune temperatuurirekord, on ka maksimaalne (hoiatus)temperatuur ja hüsterees Nad kasutavad kahte baiti, kuid erinevalt esimesest ei arvesta nad 11 bitti (kaheksandik kraadi), vaid 9 (pool kraadi), nii et isegi väiksema väärtuse salvestamisel võetakse arvesse ainult selle eraldusvõime intervalle.
|
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
}
}
}
|
Kuna eelmises koodis muudetakse ainult hoiatusega seotud temperatuuride konfiguratsiooni, siis ülejäänud toiming vastab vaikekonfiguratsioonile.
Selles vaikekonfiguratsioonis on olulised kaks omadust, esiteks hoiatusrežiim, vaikimisi nn "termostaadi režiim", mis seisneb hoiatuse aktiveerimises, kui maksimaalne temperatuur (või hoiatus) on saavutatud, ja seda ei desaktiveerita enne, kui see langeb temperatuurini. temperatuur hüsterees. Alternatiiviks on "katkestusrežiim", mille puhul signaal aktiveeritakse, kui see ületab maksimumi või kui see saavutab väärtuse, mis on väiksem kui hüsterees ja lähtestatakse mis tahes kirje, tavaliselt hetketemperatuuri lugemisega.
Teine omadus on see, et hoiatussignaal aktiveeritakse madalal tasemel, st OS-i viik on kõrgel tasemel kuni maksimaalse hoiatustemperatuuri saavutamiseni. Kuna hoiatussignaali polaarsus (tase, millel see aktiveeritakse) on konfigureeritav, piisab mõne lihtsa paigalduse korral selle signaali (riistvara) kasutamisest LM75 kasutamiseks, näiteks ventilaatori ühendamiseks või lahtiühendamiseks, kui süsteem saavutab teatud temperatuuri.
Samuti on võimalik LM75 tööd konfigureerida nii, et see ei hoiataks kohe pärast hoiatustemperatuuri saavutamist, vaid teeb seda pärast mitmeid intsidente. See käitumine on väga kasulik, kui töötate temperatuuripiiranguga või kui see muutub väga kiiresti. LM75 saab konfigureerida hoiatama pärast maksimaalse temperatuuri ületamist üks, kaks, neli või kuus korda.
Konfiguratsiooniregistris on ka natukene LM75 deaktiveerimiseks ("välja lülitamiseks") ja madala tarbimise režiimi sisenemiseks, millest väljutakse seda bitti uuesti muutes või lihtsalt järgmise registri lugemisel.
|
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
}
}
|
Postita kommentaar