Sensore di temperatura I2C LM75
Principio operativo
El IC LM75 è un Sensore di temperatura con banda proibita a semiconduttore in silicio.
Nei semiconduttori, il banda proibita È la zona energetica degli elettroni che non può essere aumentata con l'aumento del campo elettrico poiché non ci sono stati disponibili per muoversi più velocemente. Questo banda proibita è compreso tra i banda di valenza (energia inferiore) e il banda di guida (energia superiore). L’eccitazione termica (l’aumento della temperatura, per gli scopi che ci interessano) può far sì che alcuni elettroni acquisiscano energia sufficiente per passare nella banda di guida.
Come spiegato nel precedente articolo sul misurazione elettronica della temperatura, nei metalli, sebbene il numero dei portatori non dipenda dalla temperatura (tutti gli elettroni sono sempre disponibili), la loro mobilità è influenzata dalla temperatura, per cui la resistenza nei metalli aumenta con la temperatura per la diminuzione della velocità degli elettroni dovuta alla l'aumento del loro agitazione termica e la dispersione degli elettroni che produce.
Nel caso dei semiconduttori, a causa della presenza di questo banda proibita Il numero di portatori dipende dalla temperatura (a seconda del Distribuzione di Fermi-Dirac) provocando un aumento della conduttività con la temperatura. Nei semiconduttori l'aumento della temperatura produce un aumento della resistenza ma produce anche un (ulteriore) aumento della conduttività.
I sensori di temperatura con bandgap a semiconduttore in silicio, come nel caso dell'LM75, funzionano secondo questo principio, consentendo di determinare la temperatura quantificando la sua influenza sulla tensione in un diodo al silicio.
Componenti hardware LM75
L'LM75 ha anche un convertitore analogico-digitale con modulazione Sigma-Delta che si occupa di ottenere il valore numerico (digitale) della temperatura, valore che viene successivamente memorizzato (ogni 100 ms) in un suo registro da cui può essere letto tramite il bus I2C.
Oltre al registro che contiene la temperatura misurata, l'LM75 dispone di un registro in cui è possibile memorizzare una temperatura massima e di un comparatore in grado di generare un segnale se la temperatura misurata supera quella memorizzata in questo secondo registro. Per non lanciare nuovamente l'avviso finché la temperatura misurata non scende al di sotto di un certo livello, un terzo registro permette di memorizzare un valore per la temperatura di isteresi.
La configurazione del funzionamento dell'LM75 è memorizzata in un quarto registro con il quale vengono determinate le condizioni in cui viene generato l'avviso, il modo di lanciare questo segnale di avviso (modalità di interruzione o modalità di confronto) nonché l'attivazione del dispositivo (modalità). funzionamento normale o basso consumo) tra gli altri parametri.
Specifiche tecniche e implementazione dell'LM75
L'intervallo di temperature che l'LM75 è in grado di misurare varia da −55 °C a +125 °C e la risoluzione numerica è 0.125 °C sebbene la precisione sia solo ±2 °C nel migliore dei casi, quando la temperatura è compresa tra - 25 °C e +100 °C e una precisione di ±3 °C con le temperature più estreme, tra −55 °C e +125 °C.
L'implementazione (hardware) dell'LM75 in un circuito è molto semplice, non necessita di più componenti rispetto ai resistori tirare su del autobus I2C e può essere alimentato con una tensione compresa tra 2,8 V e 5,5 V. Nello stesso autobus I2C Si possono organizzare fino a otto termometri LM75 configurandone l'indirizzo con i tre pin A0, A1 e A2 a livello alto o basso, come si usa in questi casi.
D'altro canto l'utilizzo dell'LM75 come sonda risulta scomodo a causa delle confezioni in cui viene presentato, TSSOP (TSSOP8) O SEC (SO8) e viene normalmente utilizzato per misurare la temperatura ambiente o per misurare la temperatura di componenti disposti nell'ambiente del PCB in cui si trova il termometro LM75.
All'avvio, l'LM75 è configurato per rilevare una temperatura massima di +80°C, una temperatura di isteresi di +75 °C e la modalità di funzionamento comparatore, cioè la modalità che emula il funzionamento di un termostato: attiva l'avviso quando viene raggiunta la temperatura massima e solo se questa scende al di sotto della isteresi Rigenera l'avviso.
Sfruttamento dell'LM75 da un microcontrollore tramite il bus I2C
Grazie all'utilizzo di autobus I2C Il funzionamento dell'LM75 è molto semplice, basta accedere all'indirizzo che occupa sul bus per memorizzare o leggere la configurazione e per ottenere il valore della temperatura misurata.
L'indirizzo I2C la base dell'LM75 è 0B01001XXX ed è integrata, come spiegato sopra, dagli ultimi tre bit di indirizzo che vengono impostati dall'hardware con i pin A0, A1 e A2 alti (valore uno) o bassi (valore zero).
L'LM75 come termometro
All'indirizzo 0x00 si trova il registro che memorizza l'ultima temperatura misurata (TEMP), all'indirizzo 0x01 è il registro di configurazione (CONF), il registro che memorizza la temperatura isteresi all'indirizzo 0x02 e la massima o sovratemperatura (TOS) ha indirizzo 0x03. Fatta eccezione per la temperatura attuale (TEMP), funzionano tutti in lettura e scrittura.
Utilizzando alcuni esempi di codice sviluppati per Arduino (divenuto quasi un riferimento universale) il funzionamento dell'LM75 può essere ulteriormente chiarito. L'esempio più utile e basilare è utilizzare l'LM75 come termometro leggendo la registrazione dell'ultima temperatura misurata.
|
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
}
|
Il processo è quello usuale quando si lavora con un dispositivo I2C:
- Aggiungi la libreria I2C al codice con
#include <Wire.h> - Inizializzare la libreria I2C utilizzando
Wire.begin(); - Accedere al sensore di temperatura LM75 utilizzando
Wire.beginTransmission(DIRECCION_LM75) - Inviare l'indirizzo del registro a cui si accede utilizzando
Wire.write(REGISTRO) - Rilasciare il autobus I2C con
Wire.endTransmission() - Riaccedere a LM75
- Richiedi il valore del registro con
Wire.requestFrom(DIRECCION,CANTIDAD) - Verificare che i dati siano stati ricevuti utilizzando
Wire.available() - Leggere il valore richiesto
Wire.read()(tante volte quanti sono i byte che lo compongono) - Sebbene non sia essenziale, una volta terminato, rilasciare il file autobus I2C
Oltre al consueto protocollo per ottenere o archiviare informazioni nei registri del dispositivo utilizzando il file autobus I2C, per sfruttare i dati che fornisce l'LM75 è necessario considerare il formato in cui esso rappresenta internamente la temperatura.
Ottenere il valore memorizzato nelle registrazioni della temperatura dell'LM75
Alla riga 22 del codice dell'esempio precedente è possibile vedere come caricare le informazioni memorizzate dai tre registri di temperatura dell'LM75. Utilizza due byte (16 bit) di cui sono validi solo gli 11 bit più significativi. Per leggere la temperatura come numero intero (con il segno codificato in complemento a due) il byte più significativo viene caricato per primo in una variabile int de Arduino e lo si ruota di 8 bit a sinistra, lasciandolo nella parte più significativa del int. Il secondo byte viene quindi letto e aggiunto alla variabile. int con un'operazione OR
Interpretazione del valore di temperatura caricato dell'LM75
Alla riga 24 puoi vedere come interpretare il valore della temperatura. Innanzitutto occorre dividere per 32 come numero intero (ruotare i relativi 11 bit senza perdere il segno) e dividere per 8, che è il numero di "passi" con cui viene rappresentata la temperatura (ottave di grado) per ottenere un valore di tipo float con i relativi decimali. Poiché i compilatori (incluso il catena degli strumenti de Arduino) ottimizzare la divisione intera per 32, non è necessario preservare il segno e ruotare "manualmente" i bit, poiché l'operazione non è (apprezzabilmente) più veloce.
Verificare la ricezione dei dati dal bus I2C
Anche se il codice precedente funzionerà senza problemi nonostante non verifichi se sono arrivati i dati richiesti dal dispositivo. autobus I2C, la cosa più ortodossa (e consigliabile) è attendere che arrivino i dati in numero adeguato. Poiché la velocità di trasmissione e la resistenza agli errori sono più che sufficienti, è frequente trovare codici in cui i dati vengono semplicemente richiesti e letti senza attendere. Per gli esempi è utile fare così poiché non distraggono dall'intenzione principale ma per il codice di produzione è consigliabile farlo come suggerito nel settimo punto dell'elenco del processo di comunicazione I2C. Il codice nell'esempio seguente evidenzia le modifiche consigliate per utilizzare l'LM75 nella fase di sfruttamento.
|
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
}
|
Configurare il funzionamento dell'LM75
La configurazione più elementare dell'LM75 consiste nello stabilire la temperatura massima per generare l'avviso e il isteresi, che determinerà quando verrà disattivato e potrà essere ripetuto. Per configurare questi valori devi solo memorizzarli nei registri corrispondenti.
Come il record della temperatura attuale, la temperatura massima (avvertimento) e isteresi Usano due byte ma a differenza dei primi non considerano 11 bit (un ottavo di grado) ma 9 (mezzo grado) per cui, anche se venisse memorizzato un valore minore, verrebbero considerati solo intervalli di questa risoluzione.
|
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
}
}
}
|
Poiché nel codice precedente viene modificata solo la configurazione delle temperature relative all'avviso, il resto del funzionamento corrisponde alla configurazione di default.
In questa configurazione predefinita ci sono due caratteristiche rilevanti, in primo luogo la modalità di avviso, per impostazione predefinita quella che viene chiamata "modalità termostato" che consiste nell'attivare l'avviso quando viene raggiunta la temperatura massima (o avviso) e nel non disattivarlo finché non scende al di sotto della temperatura massima (o avviso). temperatura di isteresi. L'alternativa è la "modalità interruzione", in cui il segnale si attiva quando supera il massimo o quando raggiunge un valore inferiore a quello del isteresi e viene ripristinato leggendo qualsiasi record, normalmente la temperatura corrente.
La seconda caratteristica è che il segnale di avviso viene attivato a livello basso, ovvero il pin del sistema operativo è a livello alto fino al raggiungimento della temperatura di avviso massima. Poiché la polarità del segnale di avviso (il livello al quale viene attivato) è configurabile, in alcune installazioni semplici sarà sufficiente utilizzare questo segnale (hardware) per sfruttare l'LM75, ad esempio, collegando o scollegando un ventilatore quando il sistema raggiunge una certa temperatura.
È anche possibile configurare il funzionamento dell'LM75 in modo che non avvisi immediatamente dopo aver raggiunto la temperatura di avviso ma lo faccia dopo diversi incidenti. Questo comportamento è molto utile quando si lavora al limite della temperatura o quando questa varia molto rapidamente. L'LM75 può essere configurato per avvisare dopo il superamento della temperatura massima una, due, quattro o sei volte.
Nel registro di configurazione è presente anche un bit per disattivare ("spegnere") l'LM75 ed entrare in una modalità a basso consumo, dalla quale si esce modificando nuovamente questo bit o semplicemente leggendo il registro successivo.
|
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
}
}
|
Invia commento