I2C temperatūros jutiklis LM75
Veikimo principas
El IC LM75 yra a Silicio puslaidininkinis juostos temperatūros jutiklis.
Puslaidininkiuose, draudžiama juosta Tai yra elektronų energijos zona, kurios negalima padidinti didėjant elektriniam laukui, nes nėra būsenų, kurios galėtų judėti greičiau. Tai draudžiama juosta yra įtrauktas tarp valentinė juosta (mažesnė energija) ir laidumo juosta (didesnė energija). Dėl terminio sužadinimo (temperatūros padidėjimo mums svarbiais tikslais) kai kurie elektronai gali įgyti pakankamai energijos, kad galėtų patekti į laidumo juosta.
Kaip paaiškinta ankstesniame straipsnyje apie elektroninis temperatūros matavimas, metaluose, nors nešiklių skaičius nepriklauso nuo temperatūros (visi elektronai yra visada), jų judrumą veikia temperatūra, todėl atsparumas metaluose didėja didėjant temperatūrai dėl elektronų greičio mažėjimo dėl jų padidėjimas terminis maišymas ir jos sukuriamų elektronų sklaida.
Puslaidininkių atveju dėl to draudžiama juosta Nešiklių skaičius priklauso nuo temperatūros (priklausomai nuo Fermi-Dirac pasiskirstymas), todėl laidumas didėja didėjant temperatūrai. Puslaidininkiuose didėjanti temperatūra padidina atsparumą, bet taip pat (toliau) padidina laidumą.
Los silicio puslaidininkiniai juostos temperatūros jutikliai, kaip ir LM75 atveju, veikia pagal šį principą, leidžiantį nustatyti temperatūrą kiekybiškai įvertinant jos įtaką įtampai silicio diode.
LM75 aparatūros komponentai
LM75 taip pat turi a analoginis-skaitmeninis keitiklis su Sigma-Delta moduliacija kuri yra atsakinga už skaitinės (skaitmeninės) temperatūros vertės gavimą, kuri vėliau išsaugoma (kas 100 ms) viename iš jos registrų, iš kurio ją galima nuskaityti per magistralę. I2C.
Be registro, kuriame yra išmatuota temperatūra, LM75 turi registrą, kuriame galima įrašyti maksimalią temperatūrą, taip pat lyginamąjį įrenginį, galintį generuoti signalą, jei išmatuota temperatūra viršija saugomą šiame antrame registre. Kad įspėjimas nebūtų paleistas, kol išmatuota temperatūra nukris žemiau tam tikro lygio, trečiasis registras leidžia išsaugoti temperatūros vertę isterezė.
LM75 veikimo konfigūracija saugoma ketvirtame registre, kuriame nustatomos sąlygos, kuriomis generuojamas įspėjimas, šio įspėjamojo signalo paleidimo būdas (pertraukimo režimas arba palyginimo režimas), taip pat įrenginio įjungimas (režimas). . normaliam veikimui arba mažoms sąnaudoms) tarp kitų parametrų.
LM75 techninės specifikacijos ir įgyvendinimas
Temperatūros diapazonas, kurį gali išmatuoti LM75, svyruoja nuo –55°C iki +125°C, o skaitmeninė skiriamoji geba yra 0.125°C, nors tikslumas geriausiu atveju yra tik ±2°C, kai temperatūra yra tarp – 25 °C ir +100 °C, o tikslumas ±3 °C esant ekstremaliausioms temperatūroms, nuo –55 °C iki +125 °C.
LM75 įdiegimas (aparatinė įranga) grandinėje yra labai paprastas, jai nereikia daugiau komponentų nei rezistorių prisitraukimas del autobusas I2C ir gali būti maitinamas nuo 2,8 V iki 5,5 V įtampa autobusas I2C Galima išdėstyti iki aštuonių LM75 termometrų, sukonfigūravus jų adresą su trimis kaiščiais A0, A1 ir A2 aukštame arba žemame lygyje, kaip įprasta šiais atvejais.
Kita vertus, naudoti LM75 kaip zondą yra nepatogu dėl pakuotės, kurioje jis pateikiamas, TSSOP (TSSOP8) o SEC (SO8) ir paprastai naudojamas aplinkos temperatūrai arba komponentų, esančių įrenginio aplinkoje, temperatūrai matuoti. PCB kuriame yra termometras LM75.
Paleidžiant LM75 yra sukonfigūruotas aptikti maksimalią +80°C temperatūrą, isterezė +75 °C ir lyginamąjį darbo režimą, tai yra režimą, kuris imituoja termostato veikimą: jis įjungia įspėjimą, kai pasiekiama maksimali temperatūra ir tik tada, kai ji nukrenta žemiau isterezė Atkuria pranešimą.
LM75 išnaudojimas iš mikrovaldiklio per I2C magistralę
Ačiū naudoti autobusas I2C LM75 valdymas yra labai paprastas, tereikia pasiekti adresą, kurį jis užima magistrale, kad išsaugotumėte arba nuskaitytumėte konfigūraciją ir gautumėte išmatuotos temperatūros vertę.
Adresas I2C LM75 bazė yra 0B01001XXX ir, kaip paaiškinta aukščiau, yra papildyta paskutiniais trimis adreso bitais, kuriuos nustato aparatinė įranga su kaiščiais A0, A1 ir A2 aukštu (viena reikšmė) arba žemu (nulio reikšmė).
LM75 kaip termometras
Registras, kuriame saugoma paskutinė išmatuota temperatūra (TEMP), yra adresu 0x00, konfigūracijos registras (CONF) yra adresu 0x01, registras, kuriame saugoma temperatūra isterezė adresu 0x02, o maksimali arba per didelė temperatūra (TOS) turi adresą 0x03. Išskyrus esamą temperatūrą (TEMP), visi jie veikia kaip skaitymas ir rašymas.
Naudojant keletą kodų pavyzdžių, sukurtų Arduino (tapo beveik visuotine nuoroda) LM75 veikimą galima patikslinti. Pats paprasčiausias naudingas pavyzdys yra naudoti LM75 kaip termometrą, nuskaitant paskutinės išmatuotos temperatūros įrašą.
|
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
}
|
Procesas yra įprastas dirbant su įrenginiu I2C:
- Pridėti biblioteką I2C prie kodo su
#include <Wire.h> - Inicijuoti biblioteką I2C naudojant
Wire.begin(); - Pasiekite LM75 temperatūros jutiklį naudodami
Wire.beginTransmission(DIRECCION_LM75) - Siųskite registro, prie kurio prisijungėte, adresą
Wire.write(REGISTRO) - Atleiskite autobusas I2C su
Wire.endTransmission() - Iš naujo pasiekite LM75
- Paprašykite registro vertės su
Wire.requestFrom(DIRECCION,CANTIDAD) - Patikrinkite, ar duomenys buvo gauti naudojant
Wire.available() - Perskaitykite prašomą vertę
Wire.read()(tiek kartų, kiek baitų sudaro) - Nors tai nėra būtina, baigę atleiskite autobusas I2C
Be įprasto informacijos gavimo arba saugojimo įrenginio žurnaluose protokolo naudojant autobusas I2C, norint išnaudoti LM75 teikiamus duomenis, būtina atsižvelgti į formatą, kuriuo jis viduje rodo temperatūrą.
LM75 temperatūros įrašuose saugomos vertės gavimas
Ankstesnio pavyzdžio kodo 22 eilutėje galite pamatyti, kaip įkelti informaciją, saugomą trijuose LM75 temperatūros registruose. Jis naudoja du baitus (16 bitų), iš kurių galioja tik 11 reikšmingiausių bitų. Norėdami nuskaityti temperatūrą kaip sveikąjį skaičių (su užkoduotu ženklu dviejų papildymas) į kintamąjį pirmiausia įkeliamas reikšmingiausias baitas int de Arduino ir jis pasuktas 8 bitais į kairę, paliekant jį svarbiausioje dalyje int. Tada antrasis baitas nuskaitomas ir pridedamas prie kintamojo. int su ARBA operacija
LM75 pakrautos temperatūros vertės aiškinimas
24 eilutėje galite pamatyti, kaip interpretuoti temperatūros reikšmę. Visų pirma, reikia padalyti iš 32 kaip sveiką skaičių (pasukti atitinkamus 11 bitų neprarandant ženklo) ir padalinti iš 8, tai yra „žingsnių“, kuriais atvaizduojama temperatūra, skaičius (laipsnio oktavos) gauti tipo reikšmę float su atitinkamais dešimtainiais skaičiais. Kadangi kompiliatoriai (įskaitant įrankių grandinė de Arduino) optimizuoti sveikųjų skaičių padalijimą iš 32, nebūtina išsaugoti ženklo ir „rankiniu būdu“ sukti bitų, nes operacija nėra (apčiuopiamai) greitesnė.
Patikrinkite duomenų priėmimą iš I2C magistralės
Nors ankstesnis kodas veiks be problemų, nepaisant to, kad nepatikrinsite, ar įrenginio prašomi duomenys atkeliavo. autobusas I2C, ortodoksiausia (ir patartina) yra palaukti, kol atkeliaus atitinkamas skaičius duomenų. Kadangi perdavimo greitis ir atsparumas klaidoms yra daugiau nei pakankami, įprasta rasti kodą, kuriame duomenų tiesiog prašoma ir nuskaitoma nelaukiant. Pavyzdžiams naudinga tai padaryti taip, nes jie neatitraukia dėmesio nuo pagrindinės intencijos, tačiau gaminant kodą patartina tai padaryti taip, kaip siūloma komunikacijos proceso sąrašo septintame punkte. I2C. Šiame pavyzdyje pateiktas kodas pabrėžia rekomenduojamus pakeitimus, kad būtų galima naudoti LM75 eksploatavimo etape.
|
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
}
|
Konfigūruokite LM75 veikimą
Paprasčiausią LM75 konfigūraciją sudaro maksimalios temperatūros nustatymas, kad būtų generuojamas įspėjimas ir isterezė, kuris nustatys, kada jis bus išjungtas ir gali būti kartojamas. Norėdami sukonfigūruoti šias reikšmes, tereikia jas išsaugoti atitinkamuose registruose.
Kaip ir dabartinis temperatūros rekordas, maksimali (įspėjamoji) temperatūra ir isterezė Jie naudoja du baitus, tačiau skirtingai nei pirmieji, jie atsižvelgia ne į 11 bitų (aštuntą laipsnio), o į 9 (pusę laipsnio), todėl, net jei būtų saugoma mažesnė reikšmė, būtų atsižvelgiama tik į šios skiriamosios gebos intervalus.
|
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
}
}
}
|
Kadangi ankstesniame kode keičiama tik su įspėjimu susijusių temperatūrų konfigūracija, likusios operacijos dalis atitinka numatytąją konfigūraciją.
Šioje numatytojoje konfigūracijoje yra svarbios dvi charakteristikos, pirma, įspėjimo režimas, pagal numatytuosius nustatymus vadinamas "termostato režimu", kurį sudaro įspėjimo įjungimas, kai pasiekiama maksimali temperatūra (arba įspėjimas), o ne išjungimas, kol nukris iki temperatūra isterezė. Alternatyva yra „pertraukimo režimas“, kai signalas įjungiamas, kai jis viršija maksimumą arba kai pasiekia mažesnę reikšmę nei isterezė ir nustatoma iš naujo nuskaitant bet kokį įrašą, paprastai dabartinę temperatūrą.
Antroji charakteristika yra ta, kad įspėjamasis signalas įjungiamas žemu lygiu, tai yra, OS kaištis yra aukšto lygio, kol pasiekiama maksimali įspėjimo temperatūra. Kadangi įspėjamojo signalo poliškumas (lygis, kuriuo jis įjungiamas) yra konfigūruojamas, kai kuriuose paprastuose įrenginiuose pakaks naudoti šį signalą (aparatinę įrangą), kad būtų galima išnaudoti LM75, pavyzdžiui, prijungiant arba atjungiant ventiliatorių, kai sistema pasiekia tam tikrą temperatūrą.
Taip pat galima sukonfigūruoti LM75 veikimą taip, kad jis neperspėtų iš karto pasiekęs perspėjimo temperatūrą, o tai padarytų po kelių incidentų. Šis elgesys labai naudingas dirbant esant ribinei temperatūrai arba kai ji labai greitai kinta. LM75 gali būti sukonfigūruotas taip, kad perspėtų vieną, du, keturis ar šešis kartus viršijus maksimalią temperatūrą.
Konfigūracijos registre taip pat yra šiek tiek deaktyvuoti ("išjungti") LM75 ir pereiti į mažo suvartojimo režimą, iš kurio išeinama dar kartą pakeitus šį bitą arba tiesiog nuskaitant kitą registrą.
|
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
}
}
|
Rašyti komentarą