I2C temperatura sensor LM75
Prinsipyo sa pagpapatakbo
El IC Ang LM75 ay isang sensor ng temperatura ng silicon semiconductor bandgap.
Sa semiconductors, ang bawal na banda Ito ay ang energy zone ng mga electron na hindi maaaring tumaas sa isang pagtaas sa electric field dahil walang mga estado na magagamit upang lumipat nang mas mabilis. Ito bawal na banda ay kasama sa pagitan ng bandang valence (mas mababang enerhiya) at ang banda ng pagpapadaloy (mas mataas na enerhiya). Ang thermal excitation (ang pagtaas ng temperatura, para sa mga layunin na interesado tayo) ay maaaring maging sanhi ng ilang mga electron na makakuha ng sapat na enerhiya upang makapasok sa banda ng pagpapadaloy.
Gaya ng ipinaliwanag sa nakaraang artikulo tungkol sa elektronikong pagsukat ng temperatura, sa mga metal, kahit na ang bilang ng mga carrier ay hindi nakasalalay sa temperatura (lahat ng mga electron ay palaging magagamit), ang kanilang kadaliang kumilos ay apektado ng temperatura, upang ang paglaban sa mga metal ay tumaas sa temperatura dahil sa pagbaba ng bilis ng mga electron dahil sa ang pagtaas ng kanilang thermal agitation at ang pagkalat ng mga electron na ginagawa nito.
Sa kaso ng semiconductors, dahil sa pagkakaroon nito bawal na banda Ang bilang ng mga carrier ay nakadepende sa temperatura (depende sa Pamamahagi ng Fermi–Dirac) na nagiging sanhi ng pagtaas ng conductivity sa temperatura. Sa mga semiconductor, ang pagtaas ng temperatura ay nagdudulot ng pagtaas ng resistensya ngunit nagdudulot din ng (karagdagang) pagtaas sa conductivity.
Los mga sensor ng temperatura ng silicon semiconductor bandgap, tulad ng kaso ng LM75, gumagana ayon sa prinsipyong ito, na nagpapahintulot sa temperatura na matukoy sa pamamagitan ng pagsukat ng impluwensya nito sa boltahe sa isang silicon diode.
Mga Bahagi ng Hardware ng LM75
Ang LM75 ay mayroon ding isang analog-digital converter sa pamamagitan ng Sigma-Delta modulation na responsable para sa pagkuha ng numerical (digital) na halaga ng temperatura, isang halaga na kasunod na iniimbak (bawat 100 ms) sa isa sa mga rehistro nito kung saan maaari itong basahin sa pamamagitan ng bus I2C.
Bilang karagdagan sa rehistro na naglalaman ng sinusukat na temperatura, ang LM75 ay may rehistro kung saan ang pinakamataas na temperatura ay maaaring maimbak pati na rin ang isang comparator na may kakayahang makabuo ng signal kung ang sinusukat na temperatura ay lumampas sa nakaimbak sa pangalawang rehistrong ito. Upang hindi mailunsad muli ang babala hanggang sa bumaba ang sinusukat na temperatura sa ibaba ng isang tiyak na antas, pinapayagan ng ikatlong rehistro ang pag-imbak ng isang halaga para sa temperatura ng hysteresis.
Ang pagsasaayos ng operasyon ng LM75 ay naka-imbak sa isang ika-apat na rehistro kung saan ang mga kondisyon kung saan nabuo ang babala, ang paraan ng paglulunsad ng signal ng babala na ito (mode ng pagkagambala o mode ng paghahambing) pati na rin ang pag-activate ng aparato (mode) ay tinutukoy. . normal na operasyon o mababang pagkonsumo) bukod sa iba pang mga parameter.
Mga teknikal na pagtutukoy at pagpapatupad ng LM75
Ang hanay ng mga temperatura na kayang sukatin ng LM75 ay nag-iiba mula −55 °C hanggang +125 °C at ang numerical na resolution ay 0.125 °C kahit na ang katumpakan ay ±2 °C lamang sa pinakamagandang kaso, kapag ang temperatura ay nasa pagitan ng − 25 °C at +100 °C at isang katumpakan ng ±3 °C na may pinakamatinding temperatura, sa pagitan ng −55 °C at +125 °C.
Ang pagpapatupad (hardware) ng LM75 sa isang circuit ay napaka-simple, hindi ito nangangailangan ng higit pang mga bahagi kaysa sa mga resistors hilahin mo del bus I2C at maaaring paandarin ng boltahe sa pagitan ng 2,8 V at 5,5 V. Sa parehong bus I2C Hanggang walong LM75 thermometer ang maaaring isaayos sa pamamagitan ng pag-configure ng kanilang address gamit ang tatlong pin na A0, A1 at A2 sa mataas o mababang antas, gaya ng karaniwan sa mga kasong ito.
Sa kabilang banda, ang paggamit ng LM75 bilang isang probe ay hindi komportable dahil sa mga pakete kung saan ito ipinakita, TSSOP (TSSOP8) O KARAPATAN (SO8) at karaniwang ginagamit upang sukatin ang temperatura ng kapaligiran o upang sukatin ang temperatura ng mga bahagi na nakaayos sa kapaligiran ng PCB kung saan matatagpuan ang LM75 thermometer.
Sa pagsisimula, ang LM75 ay naka-configure upang makita ang maximum na temperatura na +80°C, isang temperatura na hysteresis ng +75 °C at ang comparator operating mode, iyon ay, ang mode na tumutulad sa pagpapatakbo ng isang termostat: ina-activate nito ang babala kapag naabot ang pinakamataas na temperatura at kung ito ay bumaba sa ibaba ng hysteresis Binubuo muli ang paunawa.
Pagsasamantala ng LM75 mula sa isang microcontroller sa pamamagitan ng I2C bus
Salamat sa paggamit ng bus I2C Ang pagpapatakbo ng LM75 ay napaka-simple, i-access lamang ang address na inookupahan nito sa bus upang iimbak o basahin ang configuration at upang makuha ang halaga ng sinusukat na temperatura.
Ang address I2C base ng LM75 ay 0B01001XXX at dinadagdagan, gaya ng ipinaliwanag sa itaas, ng huling tatlong address bit na itinakda ng hardware na may mga pin na A0, A1 at A2 na mataas (value one) o mababa (value zero).
Ang LM75 bilang isang thermometer
Ang rehistro na nag-iimbak ng huling sinusukat na temperatura (TEMP) ay matatagpuan sa address na 0x00, ang configuration register (CONF) ay nasa address 0x01, ang rehistro na nag-iimbak ng temperatura ng hysteresis sa address na 0x02 at ang maximum o over-temperature (TOS) ay may address na 0x03. Maliban sa kasalukuyang temperatura (TEMP), lahat ng mga ito ay gumagana bilang read at write.
Gamit ang ilang mga halimbawa ng code na binuo para sa Arduino (na naging halos isang unibersal na sanggunian) ang pagpapatakbo ng LM75 ay maaaring higit pang linawin. Ang pinakapangunahing kapaki-pakinabang na halimbawa ay ang paggamit ng LM75 bilang isang thermometer sa pamamagitan ng pagbabasa ng talaan ng huling nasukat na temperatura.
|
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
}
|
Ang proseso ay karaniwan kapag nagtatrabaho sa isang device I2C:
- Idagdag ang library I2C sa code na may
#include <Wire.h> - Magsimula sa library I2C paggamit
Wire.begin(); - I-access ang LM75 temperature sensor sa pamamagitan ng
Wire.beginTransmission(DIRECCION_LM75) - Ipadala ang address ng registry na na-access gamit ang
Wire.write(REGISTRO) - Pakawalan ang bus I2C sa
Wire.endTransmission() - Muling i-access ang LM75
- Hilingin ang halaga ng pagpapatala sa
Wire.requestFrom(DIRECCION,CANTIDAD) - I-verify na ang data ay natanggap gamit
Wire.available() - Basahin ang hinihiling na halaga
Wire.read()(ilang beses na binubuo ng mga byte) - Bagama't hindi ito mahalaga, kapag natapos na, bitawan ang bus I2C
Bilang karagdagan sa karaniwang protocol para sa pagkuha o pag-iimbak ng impormasyon sa mga log ng device gamit ang bus I2C, upang mapagsamantalahan ang data na ibinibigay ng LM75, kinakailangang isaalang-alang ang format kung saan ito ay panloob na kumakatawan sa temperatura.
Pagkuha ng halagang nakaimbak sa mga tala ng temperatura ng LM75
Sa linya 22 ng code sa nakaraang halimbawa ay makikita mo kung paano i-load ang impormasyong nakaimbak ng tatlong mga rehistro ng temperatura ng LM75. Gumagamit ito ng dalawang byte (16 bits) kung saan ang 11 pinaka makabuluhang bits lang ang valid. Upang basahin ang temperatura bilang isang integer (na may sign na naka-encode sa pandagdag ng dalawa) ang pinaka makabuluhang byte ay unang na-load sa isang variable int de Arduino at ito ay pinaikot ng 8 bits sa kaliwa, iniiwan ito sa pinaka makabuluhang bahagi ng int. Ang pangalawang byte ay pagkatapos ay basahin at idinagdag sa variable. int na may OR na operasyon
Interpretasyon ng na-load na halaga ng temperatura ng LM75
Sa linya 24 makikita mo kung paano i-interpret ang halaga ng temperatura. Una sa lahat, ito ay kinakailangan upang hatiin sa pamamagitan ng 32 bilang isang integer (iikot ang may-katuturang 11 bits nang hindi nawawala ang sign) at hatiin sa 8, na kung saan ay ang bilang ng mga "hakbang" kung saan ang temperatura ay kinakatawan (octaves ng isang degree) upang makakuha ng isang halaga ng uri float na may kaukulang mga decimal. Dahil ang mga compiler (kabilang ang toolchain de Arduino) optimize ang integer division sa pamamagitan ng 32, ito ay hindi kinakailangan upang mapanatili ang sign at "manu-manong" paikutin ang mga bit, dahil ang operasyon ay hindi (appreciably) mas mabilis.
I-verify ang pagtanggap ng data mula sa I2C bus
Bagama't gagana ang nakaraang code nang walang problema sa kabila ng hindi pag-verify kung dumating na ang data na hiniling ng device. bus I2C, ang pinaka-orthodox (at ipinapayong) bagay ay maghintay para sa data na dumating sa naaangkop na numero. Dahil ang bilis ng paghahatid at paglaban sa mga error ay higit pa sa sapat, karaniwan na ang paghahanap ng code kung saan ang data ay hinihiling at binabasa nang hindi naghihintay. Para sa mga halimbawa, kapaki-pakinabang na gawin ito sa ganitong paraan dahil hindi sila nakakagambala sa pangunahing layunin ngunit para sa code ng produksyon ipinapayong gawin ito tulad ng iminumungkahi sa ikapitong punto ng listahan ng proseso ng komunikasyon. I2C. Itinatampok ng code sa sumusunod na halimbawa ang mga inirerekomendang pagbabago para magamit ang LM75 sa yugto ng pagsasamantala.
|
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
}
|
I-configure ang pagpapatakbo ng LM75
Ang pinakapangunahing configuration ng LM75 ay binubuo ng pagtatatag ng pinakamataas na temperatura upang makabuo ng babala at ang hysteresis, na tutukuyin kung kailan ito na-deactivate at maaaring maulit. Upang i-configure ang mga halagang ito kailangan mo lamang na iimbak ang mga ito sa kaukulang mga rehistro.
Tulad ng kasalukuyang tala ng temperatura, ang maximum (babala) na temperatura at hysteresis Gumagamit sila ng dalawang byte ngunit hindi tulad ng una hindi nila isinasaalang-alang ang 11 bits (isang ikawalo ng isang degree) ngunit 9 (kalahating degree) upang, kahit na ang isang mas maliit na halaga ay naka-imbak, ang mga pagitan lamang ng resolution na ito ay isasaalang-alang.
|
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
}
}
}
|
Dahil sa naunang code ay binago lamang ang pagsasaayos ng mga temperatura na nauugnay sa babala, ang natitirang operasyon ay tumutugma sa default na pagsasaayos.
Sa default na pagsasaayos na ito ay may dalawang katangian na may kaugnayan, una ang mode ng babala, bilang default ay tinatawag na "thermostat mode" na binubuo ng pag-activate ng babala kapag naabot ang pinakamataas na temperatura (o babala) at hindi ito i-deactivate hanggang sa ibaba sa temperatura ng hysteresis. Ang kahalili ay ang "interrupt mode", kung saan ang signal ay isinaaktibo kapag ito ay lumampas sa maximum o kapag ito ay umabot sa isang halaga na mas mababa kaysa sa hysteresis at na-reset sa pamamagitan ng pagbabasa ng anumang record, karaniwan ang kasalukuyang temperatura.
Ang pangalawang katangian ay ang signal ng babala ay isinaaktibo sa mababang antas, iyon ay, ang OS pin ay nasa mataas na antas hanggang sa maabot ang pinakamataas na temperatura ng babala. Dahil ang polarity ng signal ng babala (ang antas kung saan ito na-activate) ay maaaring i-configure, sa ilang mga simpleng pag-install ay sapat na upang gamitin ang signal na ito (hardware) upang pagsamantalahan ang LM75, halimbawa, pagkonekta o pagdiskonekta ng fan kapag ang system umabot sa isang tiyak na temperatura.
Posible rin na i-configure ang pagpapatakbo ng LM75 upang hindi ito agad na magbabala pagkatapos maabot ang temperatura ng babala ngunit ginagawa ito pagkatapos ng ilang mga insidente. Ang pag-uugali na ito ay lubhang kapaki-pakinabang kapag nagtatrabaho sa limitasyon ng temperatura o kapag ito ay napakabilis na nag-iiba. Ang LM75 ay maaaring i-configure upang magbigay ng babala pagkatapos lumampas sa pinakamataas na temperatura ng isa, dalawa, apat o anim na beses.
Sa rehistro ng pagsasaayos mayroon ding kaunti upang i-deactivate ("i-off") ang LM75 at pumasok sa isang mababang mode ng pagkonsumo, na lumabas sa pamamagitan ng pagpapalit muli ng bit na ito o simpleng kapag binabasa ang susunod na rehistro.
|
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
}
}
|
Post Komento