Capteur de température I2C LM75
Principe de fonctionnement
El IC LM75 est un capteur de température à bande interdite à semi-conducteur en silicium.
Dans les semi-conducteurs, le bande interdite C’est la zone d’énergie des électrons qui ne peut pas être augmentée avec une augmentation du champ électrique car il n’existe aucun état disponible pour se déplacer plus rapidement. Ce bande interdite est inclus entre le bande de valence (énergie inférieure) et le bande de conduite (énergie plus élevée). L'excitation thermique (l'augmentation de la température, pour les besoins qui nous intéressent) peut amener certains électrons à acquérir suffisamment d'énergie pour passer dans le bande de conduite.
Comme expliqué dans l'article précédent sur le mesure électronique de la température, dans les métaux, bien que le nombre de porteurs ne dépende pas de la température (tous les électrons sont toujours disponibles), leur mobilité est affectée par la température, de sorte que la résistance des métaux augmente avec la température en raison de la diminution de la vitesse des électrons due à l'augmentation de leur agitation thermique et la diffusion des électrons qu'elle produit.
Dans le cas des semi-conducteurs, du fait de la présence de ce bande interdite Le nombre de supports dépend de la température (en fonction de la Distribution de Fermi-Dirac) provoquant une augmentation de la conductivité avec la température. Dans les semi-conducteurs, l’augmentation de la température produit une augmentation de la résistance mais produit également une (encore) augmentation de la conductivité.
Les capteurs de température à bande interdite à semi-conducteurs en silicium, comme c'est le cas du LM75, fonctionnent selon ce principe, permettant de déterminer la température en quantifiant son influence sur la tension dans une diode au silicium.
Composants matériels LM75
Le LM75 dispose également d'un convertisseur analogique-numérique par modulation Sigma-Delta qui est chargé d'obtenir la valeur numérique (numérique) de la température, valeur qui est ensuite stockée (toutes les 100 ms) dans l'un de ses registres à partir duquel elle peut être lue via le bus I2C.
En plus du registre qui contient la température mesurée, le LM75 dispose d'un registre dans lequel peut être stockée une température maximale ainsi qu'un comparateur capable de générer un signal si la température mesurée dépasse celle stockée dans ce deuxième registre. Afin de ne pas relancer l'avertissement avant que la température mesurée ne descende en dessous d'un certain niveau, un troisième registre permet de stocker une valeur pour la température de hystérèse.
La configuration du fonctionnement du LM75 est stockée dans un quatrième registre avec lequel sont déterminées les conditions dans lesquelles l'avertissement est généré, la manière de lancer ce signal d'avertissement (mode interruption ou mode comparaison) ainsi que l'activation du dispositif (mode). (fonctionnement normal ou faible consommation) entre autres paramètres.
Spécifications techniques et mise en œuvre du LM75
La plage de températures que le LM75 est capable de mesurer varie de −55 °C à +125 °C et la résolution numérique est de 0.125 °C bien que la précision ne soit que de ±2 °C dans le meilleur des cas, lorsque la température est comprise entre − 25 °C et +100 °C et une précision de ±3 °C avec les températures les plus extrêmes, entre −55 °C et +125 °C.
L'implémentation (matériel) du LM75 dans un circuit est très simple, il ne nécessite pas plus de composants que de résistances pull-up de la bus I2C et peut être alimenté avec une tension comprise entre 2,8 V et 5,5 V. De la même manière bus I2C Il est possible de disposer jusqu'à huit thermomètres LM75 en configurant leur adresse avec les trois broches A0, A1 et A2 au niveau haut ou bas, comme c'est l'habitude dans ces cas.
En revanche, l'utilisation du LM75 comme sonde est inconfortable du fait des emballages dans lesquels il est présenté, POSST (TSSOP8) O SOIC (SO8) et est normalement utilisé pour mesurer la température ambiante ou pour mesurer la température de composants disposés dans l'environnement du PCB dans lequel se trouve le thermomètre LM75.
Au démarrage, le LM75 est configuré pour détecter une température maximale de +80°C, une température de hystérèse de +75 °C et le mode de fonctionnement du comparateur, c'est-à-dire le mode qui émule le fonctionnement d'un thermostat : il active l'avertissement lorsque la température maximale est atteinte et seulement si elle descend en dessous de la hystérèse Régénère l'avis.
Exploitation du LM75 depuis un microcontrôleur via le bus I2C
Merci à l'utilisation de bus I2C Le fonctionnement du LM75 est très simple, il suffit d'accéder à l'adresse qu'il occupe sur le bus pour stocker ou lire la configuration et obtenir la valeur de la température mesurée.
L'adresse I2C la base du LM75 est 0B01001XXX et est complétée, comme expliqué ci-dessus, par les trois derniers bits d'adresse qui sont définis par le matériel avec les broches A0, A1 et A2 hautes (valeur un) ou basses (valeur zéro).
Le LM75 comme thermomètre
Le registre qui stocke la dernière température mesurée (TEMP) est situé à l'adresse 0x00, le registre de configuration (CONF) est à l'adresse 0x01, le registre qui stocke la température de hystérèse à l'adresse 0x02 et la température maximale ou surchauffe (TOS) a l'adresse 0x03. À l'exception de la température actuelle (TEMP), tous fonctionnent en lecture et en écriture.
En utilisant quelques exemples de code développés pour Arduino (qui est devenu une référence quasi universelle) le fonctionnement du LM75 peut être encore précisé. L'exemple utile le plus élémentaire consiste à utiliser le LM75 comme thermomètre en lisant l'enregistrement de la dernière température mesurée.
|
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
}
|
Le processus est habituel lorsque l'on travaille avec un appareil I2C:
- Ajouter la bibliothèque I2C au code avec
#include <Wire.h> - Initialiser la bibliothèque I2C à l'aide
Wire.begin(); - Accédez au capteur de température LM75 via
Wire.beginTransmission(DIRECCION_LM75) - Envoyer l'adresse du registre consulté en utilisant
Wire.write(REGISTRO) - Relâchez le bus I2C avec
Wire.endTransmission() - Réaccéder au LM75
- Demandez la valeur de registre avec
Wire.requestFrom(DIRECCION,CANTIDAD) - Vérifiez que les données ont été reçues en utilisant
Wire.available() - Lire la valeur demandée
Wire.read()(autant de fois que d'octets le composent) - Bien que ce ne soit pas indispensable, une fois terminé, relâchez le bus I2C
En plus du protocole habituel pour obtenir ou stocker des informations dans les journaux de l'appareil à l'aide du bus I2C, pour exploiter les données fournies par le LM75, il est nécessaire de considérer le format dans lequel il représente en interne la température.
Obtention de la valeur stockée dans les enregistrements de température du LM75
Sur la ligne 22 du code de l'exemple précédent vous pouvez voir comment charger les informations stockées par les trois registres de température du LM75. Il utilise deux octets (16 bits) dont seuls les 11 bits de poids fort sont valides. Pour lire la température sous forme d'un nombre entier (avec le signe codé en complément à deux) l'octet de poids fort est chargé en premier dans une variable int de Arduino et il subit une rotation de 8 bits vers la gauche, le laissant dans la partie la plus significative du int. Le deuxième octet est ensuite lu et ajouté à la variable. int avec une opération OU
Interprétation de la valeur de température chargée du LM75
À la ligne 24, vous pouvez voir comment interpréter la valeur de la température. Tout d'abord, il faut diviser par 32 sous forme d'entier (faire tourner les 11 bits correspondants sans perdre le signe) et diviser par 8, qui est le nombre de "pas" avec lesquels la température est représentée (octaves de degré) pour obtenir une valeur de type float avec les décimales correspondantes. Depuis les compilateurs (y compris le chaîne d'outils de Arduino) optimisez la division entière par 32, il n'est pas nécessaire de conserver le signe et de faire tourner "manuellement" les bits, car l'opération n'est pas (sensiblement) plus rapide.
Vérifier la réception des données du bus I2C
Bien que le code précédent fonctionnera sans problème même s'il ne vérifie pas si les données demandées par l'appareil sont arrivées. bus I2C, la chose la plus orthodoxe (et la plus conseillée) est d'attendre que les données arrivent en nombre approprié. La vitesse de transmission et la résistance aux erreurs étant plus que suffisantes, il est courant de trouver du code dans lequel les données sont simplement demandées et lues sans attendre. Pour les exemples, il est utile de procéder de cette façon car ils ne détournent pas l'attention de l'intention principale mais pour le code de production, il est conseillé de procéder comme suggéré dans le septième point de la liste du processus de communication. I2C. Le code de l'exemple suivant met en évidence les modifications recommandées pour utiliser le LM75 en phase d'exploitation.
|
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
}
|
Configurer le fonctionnement du LM75
La configuration la plus basique du LM75 consiste à établir la température maximale pour générer l'avertissement et le hystérèse, qui déterminera quand il sera désactivé et pourra être répété. Pour configurer ces valeurs il suffit de les stocker dans les registres correspondants.
Comme l'enregistrement de température actuel, la température maximale (d'avertissement) et hystérèse Ils utilisent deux octets mais contrairement au premier ils ne considèrent pas 11 bits (un huitième de degré) mais 9 (un demi-degré) de sorte que, même si une valeur plus petite était stockée, seuls les intervalles de cette résolution seraient pris en compte.
|
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
}
}
}
|
Puisque dans le code précédent seule la configuration des températures liées à l'avertissement est modifiée, le reste de l'opération correspond à la configuration par défaut.
Dans cette configuration par défaut il y a deux caractéristiques qui sont pertinentes, d'abord le mode d'avertissement, par défaut ce qu'on appelle "mode thermostat" qui consiste à activer l'avertissement lorsque la température maximale (ou avertissement) est atteinte et à ne le désactiver qu'en dessous de la température maximale (ou avertissement). température de hystérèse. L'alternative est le "mode interruption", dans lequel le signal est activé lorsqu'il dépasse le maximum ou lorsqu'il atteint une valeur inférieure à celle du hystérèse et est réinitialisé en lisant n'importe quel enregistrement, normalement la température actuelle.
La deuxième caractéristique est que le signal d'avertissement est activé à un niveau bas, c'est-à-dire que la broche du système d'exploitation est à un niveau haut jusqu'à ce que la température maximale d'avertissement soit atteinte. Puisque la polarité du signal d'avertissement (le niveau auquel il est activé) est configurable, dans certaines installations simples, il suffira d'utiliser ce signal (matériel) pour exploiter le LM75, par exemple, connecter ou déconnecter un ventilateur lorsque le système atteint une certaine température.
Il est également possible de configurer le fonctionnement du LM75 pour qu'il n'avertisse pas immédiatement après avoir atteint la température d'avertissement mais qu'il le fasse après plusieurs incidents. Ce comportement est très utile lorsqu'on travaille à la limite de température ou lorsque celle-ci varie très rapidement. Le LM75 peut être configuré pour avertir après avoir dépassé la température maximale une, deux, quatre ou six fois.
Dans le registre de configuration il y a aussi un bit pour désactiver ("éteindre") le LM75 et entrer dans un mode basse consommation, dont on sort en changeant à nouveau ce bit ou simplement lors de la lecture du registre suivant.
|
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
}
}
|
Poster un commentaire