Sensor de temperatura I2C LM75
Principio de funcionamento
El IC LM75 é um sensor de temperatura bandgap de semicondutor de silício.
Em semicondutores, o banda proibida É a zona de energia dos elétrons que não pode ser aumentada com o aumento do campo elétrico, pois não há estados disponíveis para se mover mais rapidamente. Está banda proibida está incluído entre os banda de valência (menor energia) e o banda de condução (maior energia). A excitação térmica (o aumento da temperatura, para os propósitos que nos interessam) pode fazer com que alguns elétrons adquiram energia suficiente para passar para o banda de condução.
Como explicado no artigo anterior sobre o medição eletrônica de temperatura, nos metais, embora o número de portadores não dependa da temperatura (todos os elétrons estão sempre disponíveis), sua mobilidade é afetada pela temperatura, de modo que a resistência nos metais aumenta com a temperatura devido à diminuição da velocidade dos elétrons devido a o aumento da sua agitação térmica e o espalhamento de elétrons que ele produz.
No caso dos semicondutores, devido à presença deste banda proibida O número de transportadores depende da temperatura (dependendo do Distribuição Fermi-Dirac) fazendo com que a condutividade aumente com a temperatura. Nos semicondutores, o aumento da temperatura produz um aumento na resistência, mas também produz um (ainda) aumento na condutividade.
Os sensores de temperatura bandgap de semicondutores de silício, como é o caso do LM75, funcionam segundo este princípio, permitindo determinar a temperatura quantificando sua influência na tensão em um diodo de silício.
Componentes de hardware LM75
O LM75 também possui um conversor analógico-digital por modulação Sigma-Delta que é responsável por obter o valor numérico (digital) da temperatura, valor que posteriormente é armazenado (a cada 100 ms) em um de seus registros de onde pode ser lido via barramento I2C.
Além do registro que contém a temperatura medida, o LM75 possui um registro no qual pode ser armazenada uma temperatura máxima e também um comparador que é capaz de gerar um sinal caso a temperatura medida ultrapasse a armazenada neste segundo registro. Para não lançar novamente o aviso até que a temperatura medida desça abaixo de um determinado nível, um terceiro registo permite armazenar um valor para a temperatura do histerese.
A configuração do funcionamento do LM75 é armazenada em um quarto registro com o qual são determinadas as condições sob as quais o aviso é gerado, a forma de lançamento deste sinal de aviso (modo de interrupção ou modo de comparação), bem como a ativação do dispositivo (modo). (funcionamento normal ou baixo consumo) entre outros parâmetros.
Especificações técnicas e implementação do LM75
A faixa de temperaturas que o LM75 é capaz de medir varia de −55 °C a +125 °C e a resolução numérica é de 0.125 °C, embora a precisão seja de apenas ±2 °C no melhor caso, quando a temperatura está entre - 25 °C e +100 °C e uma precisão de ±3 °C com as temperaturas mais extremas, entre −55 °C e +125 °C.
A implementação (hardware) do LM75 em um circuito é muito simples, não necessita de mais componentes além dos resistores puxar para cima De ônibus I2C e pode ser alimentado com tensão entre 2,8 V e 5,5 V. No mesmo ônibus I2C Podem ser dispostos até oito termômetros LM75 configurando seu endereço com os três pinos A0, A1 e A2 em nível alto ou baixo, como é usual nestes casos.
Por outro lado, o uso do LM75 como sonda é incômodo devido às embalagens em que é apresentado, TSSOP (TSOP8) Ou SEC (SO8) e é normalmente usado para medir a temperatura ambiente ou para medir a temperatura de componentes dispostos no ambiente do PCB onde está localizado o termômetro LM75.
Na inicialização, o LM75 é configurado para detectar uma temperatura máxima de +80°C, uma temperatura de histerese de +75 °C e o modo de funcionamento comparador, ou seja, o modo que emula o funcionamento de um termostato: ativa o aviso quando a temperatura máxima é atingida e somente se cair abaixo do histerese Regenera o aviso.
Exploração do LM75 a partir de um microcontrolador via barramento I2C
Graças ao uso de ônibus I2C O funcionamento do LM75 é muito simples, bastando acessar o endereço que ele ocupa no barramento para armazenar ou ler a configuração e obter o valor da temperatura medida.
A direção I2C A base do LM75 é 0B01001XXX e é complementada, conforme explicado acima, pelos últimos três bits de endereço que são configurados pelo hardware com os pinos A0, A1 e A2 alto (valor um) ou baixo (valor zero).
O LM75 como termômetro
O registro que armazena a última temperatura medida (TEMP) está localizado no endereço 0x00, o registro de configuração (CONF) está no endereço 0x01, o registro que armazena a temperatura de histerese no endereço 0x02 e a temperatura máxima ou excessiva (TOS) tem endereço 0x03. Exceto a temperatura atual (TEMP), todos funcionam como leitura e gravação.
Usando alguns exemplos de código desenvolvidos para Arduino (que se tornou uma referência quase universal) o funcionamento do LM75 pode ser ainda mais esclarecido. O exemplo útil mais básico é usar o LM75 como termômetro lendo o registro da última temperatura medida.
|
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
}
|
O processo é normal ao trabalhar com um dispositivo I2C:
- Adicione a biblioteca I2C para o código com
#include <Wire.h> - Inicialize a biblioteca I2C uso
Wire.begin(); - Acesse o sensor de temperatura LM75 via
Wire.beginTransmission(DIRECCION_LM75) - Envie o endereço do registro acessado usando
Wire.write(REGISTRO) - Liberte o ônibus I2C com
Wire.endTransmission() - Acesse novamente o LM75
- Solicite o valor do registro com
Wire.requestFrom(DIRECCION,CANTIDAD) - Verifique se os dados foram recebidos usando
Wire.available() - Leia o valor solicitado
Wire.read()(quantas vezes quantos bytes o compõem) - Embora não seja essencial, quando terminar, solte o ônibus I2C
Além do protocolo usual para obtenção ou armazenamento de informações nos logs do dispositivo utilizando o ônibus I2C, para explorar os dados que o LM75 fornece é necessário considerar o formato em que ele representa internamente a temperatura.
Obtenção do valor armazenado nos registros de temperatura do LM75
Na linha 22 do código do exemplo anterior você pode ver como carregar as informações armazenadas pelos três registradores de temperatura do LM75. Ele usa dois bytes (16 bits), dos quais apenas os 11 bits mais significativos são válidos. Para ler a temperatura como um número inteiro (com o sinal codificado em complemento de dois) o byte mais significativo é carregado primeiro em uma variável int de Arduino e é girado 8 bits para a esquerda, deixando-o na parte mais significativa do int. O segundo byte é então lido e adicionado à variável. int com uma operação OR
Interpretação do valor da temperatura carregada do LM75
Na linha 24 você pode ver como interpretar o valor da temperatura. Em primeiro lugar, é necessário dividir por 32 como um número inteiro (girar os 11 bits relevantes sem perder o sinal) e dividir por 8, que é o número de “passos” com que a temperatura é representada (oitavas de grau) para obter um valor do tipo float com as casas decimais correspondentes. Como os compiladores (incluindo o toolchain de Arduino) otimizar a divisão inteira por 32, não é necessário preservar o sinal e girar "manualmente" os bits, pois a operação não é (sensivelmente) mais rápida.
Verifique a recepção de dados do barramento I2C
Embora o código anterior funcione sem problemas apesar de não verificar se os dados solicitados pelo dispositivo chegaram. ônibus I2C, o mais ortodoxo (e aconselhável) é esperar que os dados cheguem no número adequado. Como a velocidade de transmissão e a resistência a erros são mais que suficientes, é comum encontrar códigos nos quais os dados são simplesmente solicitados e lidos sem espera. Para os exemplos é útil fazê-lo desta forma, pois não desviam a atenção da intenção principal, mas para o código de produção é aconselhável fazê-lo conforme sugerido no sétimo ponto da lista do processo de comunicação I2C. O código no exemplo a seguir destaca as alterações recomendadas para usar o LM75 na fase de exploração.
|
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
}
|
Configure a operação do LM75
A configuração mais básica do LM75 consiste em estabelecer a temperatura máxima para gerar o aviso e o histerese, que determinará quando será desativado e poderá ser repetido. Para configurar estes valores basta armazená-los nos registros correspondentes.
Assim como o registro de temperatura atual, a temperatura máxima (de advertência) e histerese Utilizam dois bytes mas ao contrário do primeiro não consideram 11 bits (um oitavo de grau) mas sim 9 (meio grau) de forma que, mesmo que fosse armazenado um valor menor, apenas intervalos desta resolução seriam considerados.
|
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
}
}
}
|
Como no código anterior apenas é alterada a configuração das temperaturas relacionadas ao aviso, o resto da operação corresponde à configuração padrão.
Nesta configuração padrão existem duas características que são relevantes, em primeiro lugar o modo de aviso, por padrão o que é chamado de "modo termostato" que consiste em ativar o aviso quando a temperatura máxima (ou aviso) é atingida e não desativá-lo até que seja inferior ao temperatura de histerese. A alternativa é o “modo interrupção”, em que o sinal é acionado quando ultrapassa o máximo ou quando atinge um valor inferior ao do histerese e é zerado lendo qualquer registro, normalmente a temperatura atual.
A segunda característica é que o sinal de alerta é ativado em nível baixo, ou seja, o pino do SO fica em nível alto até que a temperatura máxima de alerta seja atingida. Como a polaridade do sinal de alerta (o nível em que é ativado) é configurável, em algumas instalações simples será suficiente utilizar este sinal (hardware) para explorar o LM75, por exemplo, conectando ou desconectando um ventilador quando o sistema atinge uma determinada temperatura.
Também é possível configurar o funcionamento do LM75 para que ele não avise imediatamente após atingir a temperatura de alerta, mas sim após vários incidentes. Este comportamento é muito útil quando se trabalha no limite de temperatura ou quando esta varia muito rapidamente. O LM75 pode ser configurado para avisar após ultrapassar a temperatura máxima uma, duas, quatro ou seis vezes.
No registro de configuração também existe um bit para desativar (“desligar”) o LM75 e entrar em modo de baixo consumo, do qual se sai alterando novamente este bit ou simplesmente na leitura do próximo registro.
|
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
}
}
|
Postar Comentário