I2C temperatursensor LM75
Driftsprinsipp
El IC LM75 er en silisium halvleder båndgap temperatursensor.
I halvledere er forbudt band Det er energisonen til elektronene som ikke kan økes med en økning i det elektriske feltet da det ikke er noen tilstander tilgjengelig for å bevege seg raskere. Dette forbudt band er inkludert mellom valensbånd (lavere energi) og ledningsband (høyere energi). Termisk eksitasjon (økningen i temperatur, for formålene vi er interessert i) kan føre til at noen elektroner får nok energi til å passere inn i ledningsband.
Som forklart i forrige artikkel om elektronisk temperaturmåling, i metaller, selv om antall bærere ikke er avhengig av temperatur (alle elektroner er alltid tilgjengelige), påvirkes mobiliteten deres av temperaturen, slik at motstanden i metaller øker med temperaturen på grunn av nedgangen i elektronenes hastighet pga. økningen i deres termisk agitasjon og spredningen av elektroner den produserer.
I tilfelle av halvledere, på grunn av tilstedeværelsen av dette forbudt band Antall bærere avhenger av temperaturen (avhengig av Fermi–Dirac-distribusjon) som får ledningsevnen til å øke med temperaturen. I halvledere gir økende temperatur en økning i motstand, men gir også en (ytterligere) økning i konduktivitet.
den silisium halvleder båndgap temperatursensorer, som tilfellet er med LM75, fungerer i henhold til dette prinsippet, slik at temperaturen kan bestemmes ved å kvantifisere dens innflytelse på spenningen i en silisiumdiode.
LM75 maskinvarekomponenter
LM75 har også en analog-digital omformer med Sigma-Delta-modulasjon som er ansvarlig for å få den numeriske (digitale) verdien til temperaturen, en verdi som deretter lagres (hver 100 ms) i et av sine registre som den kan leses fra via bussen I2C.
I tillegg til registeret som inneholder den målte temperaturen, har LM75 et register der en maksimal temperatur kan lagres samt en komparator som er i stand til å generere et signal dersom den målte temperaturen overstiger den som er lagret i dette andre registeret. For ikke å starte advarselen igjen før den målte temperaturen faller under et visst nivå, tillater et tredje register å lagre en verdi for temperaturen på hysterese.
Konfigurasjonen av LM75-operasjonen er lagret i et fjerde register som forholdene som advarselen genereres under, måten å starte dette varselsignalet på (avbruddsmodus eller sammenligningsmodus) samt aktiveringen av enheten (modus) bestemmes normal drift eller lavt forbruk) blant andre parametere.
Tekniske spesifikasjoner og implementering av LM75
Temperaturområdet som LM75 er i stand til å måle varierer fra -55 °C til +125 °C og den numeriske oppløsningen er 0.125 °C, selv om presisjonen bare er ±2 °C i beste fall, når temperaturen er mellom − 25 °C og +100 °C og en nøyaktighet på ±3 °C med de mest ekstreme temperaturene, mellom −55 °C og +125 °C.
Implementeringen (maskinvare) av LM75 i en krets er veldig enkel, den trenger ikke flere komponenter enn motstandene pull-ups den buss I2C og kan drives med en spenning mellom 2,8 V og 5,5 V. I samme buss I2C Opptil åtte LM75 termometre kan ordnes ved å konfigurere adressen deres med de tre pinnene A0, A1 og A2 på høyt eller lavt nivå, som vanligvis er vanlig i disse tilfellene.
På den annen side er bruken av LM75 som en sonde ubehagelig på grunn av pakkene den er presentert i, TSSOP (TSSOP8) eller SEC (SO8) og brukes vanligvis til å måle omgivelsestemperatur eller for å måle temperaturen på komponenter som er plassert i miljøet til PCB der LM75-termometeret er plassert.
Ved oppstart er LM75 konfigurert til å registrere en maksimal temperatur på +80°C, en temperatur på hysterese på +75 °C og komparatordriftsmodusen, det vil si modusen som emulerer driften av en termostat: den aktiverer advarselen når maksimumstemperaturen er nådd og bare hvis den faller under hysterese Regenererer varselet.
Utnyttelse av LM75 fra en mikrokontroller via I2C-bussen
Takket være bruken av buss I2C Betjeningen av LM75 er veldig enkel, bare få tilgang til adressen den opptar på bussen for å lagre eller lese konfigurasjonen og få verdien av den målte temperaturen.
Adressen I2C base av LM75 er 0B01001XXX og er supplert, som forklart ovenfor, av de tre siste adressebitene som er satt av maskinvare med pinnene A0, A1 og A2 høy (verdi én) eller lav (verdi null).
LM75 som termometer
Registeret som lagrer den sist målte temperaturen (TEMP) ligger på adressen 0x00, konfigurasjonsregisteret (CONF) er på adressen 0x01, registeret som lagrer temperaturen på hysterese ved adresse 0x02 og maksimum eller overtemperatur (TOS) har adresse 0x03. Bortsett fra gjeldende temperatur (TEMP), fungerer alle som lesing og skriving.
Ved hjelp av noen kodeeksempler utviklet for Arduino (som har blitt nesten en universell referanse) driften av LM75 kan avklares ytterligere. Det mest grunnleggende nyttige eksemplet er å bruke LM75 som et termometer ved å lese registreringen av siste målte temperatur.
|
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
}
|
Prosessen er den vanlige når du arbeider med en enhet I2C:
- Legg til biblioteket I2C til koden med
#include <Wire.h> - Initialiser biblioteket I2C hjelp
Wire.begin(); - Få tilgang til LM75 temperatursensor ved hjelp av
Wire.beginTransmission(DIRECCION_LM75) - Send adressen til registeret du får tilgang til ved hjelp av
Wire.write(REGISTRO) - Slipp buss I2C med
Wire.endTransmission() - Få tilgang til LM75 igjen
- Be om registerverdien med
Wire.requestFrom(DIRECCION,CANTIDAD) - Bekreft at data er mottatt ved hjelp av
Wire.available() - Les den forespurte verdien
Wire.read()(så mange ganger som byte utgjør det) - Selv om det ikke er avgjørende, slipper du ut når du er ferdig buss I2C
I tillegg til den vanlige protokollen for innhenting eller lagring av informasjon i enhetsloggene ved hjelp av buss I2C, for å utnytte dataene som LM75 gir, er det nødvendig å vurdere formatet der den internt representerer temperaturen.
Innhenting av verdien som er lagret i LM75 temperaturregistreringer
På linje 22 i koden i forrige eksempel kan du se hvordan du laster informasjonen som er lagret av de tre temperaturregistrene til LM75. Den bruker to byte (16 biter) hvorav bare de 11 mest signifikante bitene er gyldige. For å lese temperaturen som et heltall (med tegnet kodet inn tos komplement) den mest signifikante byten lastes først inn i en variabel int de Arduino og den roteres 8 biter til venstre, og etterlater den i den viktigste delen av int. Den andre byten blir så lest og lagt til variabelen. int med en OR-operasjon
Tolkning av den belastede temperaturverdien til LM75
I linje 24 kan du se hvordan du skal tolke temperaturverdien. Først av alt er det nødvendig å dele med 32 som et heltall (rotere de relevante 11 bitene uten å miste tegnet) og dele med 8, som er antallet "trinn" som temperaturen er representert med (oktaver av en grad) for å få en typeverdi float med tilsvarende desimaler. Siden kompilatorer (inkludert verktøysett de Arduino) optimalisere heltallsdivisjonen med 32, er det ikke nødvendig å bevare tegnet og "manuelt" rotere bitene, siden operasjonen ikke er (nevneverdig) raskere.
Bekreft datamottak fra I2C-bussen
Selv om den forrige koden vil fungere uten problemer til tross for at du ikke har verifisert om dataene som ble bedt om av enheten, har kommet. buss I2C, den mest ortodokse (og tilrådelige) tingen er å vente på at dataene kommer i riktig nummer. Siden overføringshastigheten og motstanden mot feil er mer enn tilstrekkelig, er det vanlig å finne kode der dataene ganske enkelt etterspørres og leses uten å vente. For eksemplene er det nyttig å gjøre det på denne måten siden de ikke distraherer fra hovedintensjonen, men for produksjonskoden er det tilrådelig å gjøre det som foreslått i det syvende punktet på listen over kommunikasjonsprosessen I2C. Koden i eksemplet nedenfor fremhever de anbefalte endringene for å bruke LM75 i utnyttelsesfasen.
|
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
}
|
Konfigurer driften av LM75
Den mest grunnleggende konfigurasjonen av LM75 består av å etablere maksimal temperatur for å generere advarselen og hysterese, som avgjør når den er deaktivert og kan gjentas. For å konfigurere disse verdiene trenger du bare å lagre dem i de tilsvarende registrene.
I likhet med gjeldende temperaturrekord, maksimal (varsel) temperatur og hysterese De bruker to byte, men i motsetning til den første tar de ikke hensyn til 11 biter (en åttendedel av en grad), men 9 (en halv grad), slik at selv om en mindre verdi ble lagret, vil bare intervaller av denne oppløsningen bli vurdert.
|
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
}
}
}
|
Siden i forrige kode bare konfigurasjonen av temperaturene knyttet til advarselen endres, tilsvarer resten av operasjonen standardkonfigurasjonen.
I denne standardkonfigurasjonen er det to egenskaper som er relevante, for det første varselmodusen, som standard det som kalles "termostatmodus" som består i å aktivere varselet når maksimal temperatur (eller advarsel) er nådd og ikke deaktivere den før lavere til temperatur på hysterese. Alternativet er "avbruddsmodus", der signalet aktiveres når det overskrider maksimum eller når det når en verdi som er lavere enn hysterese og tilbakestilles ved å lese en hvilken som helst post, normalt gjeldende temperatur.
Den andre egenskapen er at varselsignalet aktiveres på et lavt nivå, det vil si at OS-pinnen er på et høyt nivå inntil maksimal varseltemperatur er nådd. Siden polariteten til varselsignalet (nivået som det aktiveres på) kan konfigureres, vil det i noen enkle installasjoner være nok å bruke dette signalet (maskinvare) for å utnytte LM75, for eksempel å koble til eller fra en vifte når systemet når en viss temperatur.
Det er også mulig å konfigurere driften av LM75 slik at den ikke varsler umiddelbart etter at varseltemperaturen er nådd, men gjør det etter flere hendelser. Denne oppførselen er veldig nyttig når du arbeider ved temperaturgrensen eller når den varierer veldig raskt. LM75 kan konfigureres til å varsle etter å ha overskredet maksimumstemperaturen én, to, fire eller seks ganger.
I konfigurasjonsregisteret er det også en bit for å deaktivere ("slå av") LM75 og gå inn i en lavforbruksmodus, som avsluttes ved å endre denne biten på nytt eller rett og slett ved lesing av neste register.
|
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
}
}
|
Legg inn kommentar