Sensor suhu I2C LM75
Prinsip operasi
El IC LM75 adalah sensor suhu celah pita semikonduktor silikon.
Dalam semikonduktor, band terlarang Ini adalah zona energi elektron yang tidak dapat ditingkatkan dengan peningkatan medan listrik karena tidak ada keadaan yang dapat bergerak lebih cepat. Ini band terlarang termasuk di antara pita valensi (energi lebih rendah) dan pita konduksi (energi lebih tinggi). Eksitasi termal (peningkatan suhu, untuk tujuan yang kita minati) dapat menyebabkan beberapa elektron memperoleh energi yang cukup untuk masuk ke dalam elektron. pita konduksi.
Seperti yang telah dijelaskan pada artikel sebelumnya tentang pengukuran suhu elektronik, pada logam, walaupun jumlah pembawa tidak bergantung pada suhu (semua elektron selalu tersedia), mobilitasnya dipengaruhi oleh suhu, sehingga hambatan pada logam meningkat seiring dengan suhu karena menurunnya kecepatan elektron akibat peningkatan mereka agitasi termal dan hamburan elektron yang dihasilkannya.
Dalam kasus semikonduktor, karena adanya hal ini band terlarang Jumlah pembawa bergantung pada suhu (tergantung pada suhu). Distribusi Fermi – Dirac) menyebabkan konduktivitas meningkat seiring suhu. Dalam semikonduktor, peningkatan suhu menghasilkan peningkatan resistensi tetapi juga menghasilkan peningkatan konduktivitas (lebih lanjut).
Los sensor suhu celah pita semikonduktor silikon, seperti halnya LM75, bekerja berdasarkan prinsip ini, memungkinkan suhu ditentukan dengan mengukur pengaruhnya terhadap tegangan dalam dioda silikon.
Komponen Perangkat Keras LM75
LM75 juga memiliki konverter analog-digital dengan modulasi Sigma-Delta yang bertanggung jawab untuk memperoleh nilai numerik (digital) suhu, nilai yang selanjutnya disimpan (setiap 100 ms) di salah satu registernya yang dapat dibaca melalui bus I2C.
Selain register yang berisi suhu terukur, LM75 juga memiliki register yang dapat menyimpan suhu maksimum serta komparator yang mampu menghasilkan sinyal jika suhu terukur melebihi yang disimpan pada register kedua ini. Agar tidak meluncurkan peringatan lagi hingga suhu yang diukur turun di bawah tingkat tertentu, register ketiga memungkinkan penyimpanan nilai suhu histeresis.
Konfigurasi operasi LM75 disimpan dalam register keempat yang menentukan kondisi di mana peringatan dihasilkan, cara meluncurkan sinyal peringatan ini (mode interupsi atau mode perbandingan) serta aktivasi perangkat (mode). .operasi normal atau konsumsi rendah) di antara parameter lainnya.
Spesifikasi teknis dan implementasi LM75
Kisaran suhu yang mampu diukur oleh LM75 bervariasi dari −55 °C hingga +125 °C dan resolusi numeriknya adalah 0.125 °C meskipun presisinya hanya ±2 °C dalam kasus terbaik, ketika suhu berada di antara − 25 °C dan +100 °C dan akurasi ±3 °C dengan suhu paling ekstrim, antara −55 °C dan +125 °C.
Implementasi (hardware) LM75 dalam suatu rangkaian sangat sederhana, tidak memerlukan komponen lebih banyak dari pada resistor tarik ke atas itu bis I2C dan dapat diberi daya dengan tegangan antara 2,8 V dan 5,5 V. Sama bis I2C Hingga delapan termometer LM75 dapat diatur dengan mengonfigurasi alamatnya pada tiga pin A0, A1, dan A2 pada level tinggi atau rendah, seperti biasa dalam kasus ini.
Di sisi lain, penggunaan LM75 sebagai probe tidak nyaman karena paket yang disajikan, TSSOP (TSSOP 8) Atau DETIK (SO8) dan biasanya digunakan untuk mengukur suhu lingkungan atau untuk mengukur suhu komponen-komponen yang tersusun dalam lingkungan tersebut PCB dimana termometer LM75 berada.
Saat startup, LM75 dikonfigurasi untuk mendeteksi suhu maksimum +80°C, suhu histeresis +75 °C dan mode pengoperasian komparator, yaitu mode yang mengemulasikan pengoperasian termostat: mengaktifkan peringatan ketika suhu maksimum tercapai dan hanya jika suhu turun di bawah suhu histeresis Membuat ulang pemberitahuan.
Eksploitasi LM75 dari mikrokontroler melalui bus I2C
Berkat penggunaan bis I2C Pengoperasian LM75 sangat sederhana, cukup akses alamat yang ditempati di bus untuk menyimpan atau membaca konfigurasi dan mendapatkan nilai suhu yang diukur.
Alamatnya I2C basis LM75 adalah 0B01001XXX dan dilengkapi, seperti dijelaskan di atas, dengan tiga bit alamat terakhir yang diatur oleh perangkat keras dengan pin A0, A1 dan A2 tinggi (nilai satu) atau rendah (nilai nol).
LM75 sebagai termometer
Register yang menyimpan suhu terakhir yang diukur (TEMP) terletak di alamat 0x00, register konfigurasi (CONF) berada di alamat 0x01, register yang menyimpan suhu histeresis di alamat 0x02 dan maksimum atau suhu berlebih (TOS) memiliki alamat 0x03. Kecuali suhu saat ini (TEMP), semuanya berfungsi sebagai baca dan tulis.
Menggunakan beberapa contoh kode yang dikembangkan untuk Arduino (yang hampir menjadi referensi universal) pengoperasian LM75 dapat diperjelas lebih lanjut. Contoh paling mendasar yang berguna adalah menggunakan LM75 sebagai termometer dengan membaca catatan suhu terakhir yang diukur.
|
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
}
|
Prosesnya seperti biasa saat bekerja dengan perangkat I2C:
- Tambahkan perpustakaan I2C ke kode dengan
#include <Wire.h> - Inisialisasi perpustakaan I2C menggunakan
Wire.begin(); - Akses sensor suhu LM75 menggunakan
Wire.beginTransmission(DIRECCION_LM75) - Kirim alamat registri yang diakses menggunakan
Wire.write(REGISTRO) - Lepaskan bis I2C dengan
Wire.endTransmission() - Akses kembali LM75
- Minta nilai registri dengan
Wire.requestFrom(DIRECCION,CANTIDAD) - Verifikasi bahwa data telah diterima menggunakan
Wire.available() - Baca nilai yang diminta
Wire.read()(sebanyak byte yang dibuatnya) - Meski tidak penting, setelah selesai lepaskan bis I2C
Selain protokol biasa untuk memperoleh atau menyimpan informasi dalam log perangkat menggunakan bis I2C, untuk memanfaatkan data yang disediakan LM75, perlu mempertimbangkan format yang mewakili suhu internalnya.
Memperoleh nilai yang disimpan dalam catatan suhu LM75
Pada baris 22 kode pada contoh sebelumnya Anda dapat melihat cara memuat informasi yang disimpan oleh tiga register suhu LM75. Ia menggunakan dua byte (16 bit) yang hanya 11 bit paling signifikan yang valid. Untuk membaca suhu sebagai bilangan bulat (dengan tanda yang dikodekan pelengkap dua) byte paling signifikan dimuat terlebih dahulu ke dalam variabel int de Arduino dan diputar 8 bit ke kiri, meninggalkannya di bagian paling signifikan int. Byte kedua kemudian dibaca dan ditambahkan ke variabel. int dengan operasi OR
Interpretasi nilai suhu yang dimuat pada LM75
Pada baris 24 Anda dapat melihat cara menginterpretasikan nilai suhu. Pertama-tama, Anda perlu membaginya dengan 32 sebagai bilangan bulat (memutar 11 bit yang relevan tanpa kehilangan tandanya) dan membaginya dengan 8, yang merupakan jumlah "langkah" yang mewakili suhu (oktaf satu derajat) untuk mendapatkan nilai tipe float dengan desimal yang sesuai. Sejak kompiler (termasuk toolchain de Arduino) mengoptimalkan pembagian bilangan bulat dengan 32, tidak perlu mempertahankan tanda dan memutar bit "secara manual", karena operasinya tidak (jauh) lebih cepat.
Verifikasi penerimaan data dari bus I2C
Meskipun kode sebelumnya akan berfungsi tanpa masalah meskipun tidak memverifikasi apakah data yang diminta perangkat telah tiba. bis I2C, hal yang paling ortodoks (dan disarankan) adalah menunggu data tiba dalam jumlah yang sesuai. Karena kecepatan transmisi dan ketahanan terhadap kesalahan lebih dari cukup, biasanya ditemukan kode yang datanya hanya diminta dan dibaca tanpa menunggu. Untuk contoh-contohnya ada gunanya melakukannya dengan cara ini karena tidak mengganggu maksud utama tetapi untuk kode produksi disarankan untuk melakukannya seperti yang disarankan pada poin ketujuh dari daftar proses komunikasi. I2C. Kode dalam contoh berikut menyoroti perubahan yang disarankan untuk menggunakan LM75 dalam fase eksploitasi.
|
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
}
|
Konfigurasikan pengoperasian LM75
Konfigurasi paling dasar dari LM75 terdiri dari penetapan suhu maksimum untuk menghasilkan peringatan dan histeresis, yang akan menentukan kapan dinonaktifkan dan dapat diulang. Untuk mengonfigurasi nilai-nilai ini Anda hanya perlu menyimpannya di register yang sesuai.
Seperti catatan suhu saat ini, suhu maksimum (peringatan) dan histeresis Mereka menggunakan dua byte tetapi tidak seperti yang pertama, mereka tidak mempertimbangkan 11 bit (seperdelapan derajat) tetapi 9 (setengah derajat) sehingga, meskipun nilai yang lebih kecil disimpan, hanya interval resolusi ini yang akan dipertimbangkan.
|
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
}
}
}
|
Karena pada kode sebelumnya hanya konfigurasi suhu yang terkait dengan peringatan yang diubah, operasi selanjutnya sesuai dengan konfigurasi default.
Dalam konfigurasi default ini terdapat dua karakteristik yang relevan, pertama mode peringatan, secara default disebut "mode termostat" yang terdiri dari mengaktifkan peringatan ketika suhu (atau peringatan) maksimum tercapai dan tidak menonaktifkannya hingga lebih rendah ke suhu suhu histeresis. Alternatifnya adalah "mode interupsi", di mana sinyal diaktifkan ketika melebihi nilai maksimum atau ketika mencapai nilai yang lebih rendah dari nilai maksimum. histeresis dan diatur ulang dengan membaca catatan apa pun, biasanya suhu saat ini.
Ciri kedua adalah sinyal peringatan diaktifkan pada level rendah, yaitu pin OS berada pada level tinggi hingga suhu peringatan maksimum tercapai. Karena polaritas sinyal peringatan (tingkat pengaktifannya) dapat dikonfigurasi, dalam beberapa instalasi sederhana cukup menggunakan sinyal ini (perangkat keras) untuk mengeksploitasi LM75, misalnya, menyambungkan atau melepaskan kipas saat sistem mencapai suhu tertentu.
Dimungkinkan juga untuk mengkonfigurasi pengoperasian LM75 sehingga tidak memberikan peringatan segera setelah mencapai suhu peringatan tetapi memberikan peringatan setelah beberapa insiden. Perilaku ini sangat berguna ketika bekerja pada batas suhu atau ketika suhu berubah dengan sangat cepat. LM75 dapat dikonfigurasi untuk memperingatkan setelah melebihi suhu maksimum satu, dua, empat atau enam kali.
Pada register konfigurasi juga terdapat bit untuk menonaktifkan ("mematikan") LM75 dan memasuki mode konsumsi rendah, yang keluar dengan mengubah bit ini lagi atau cukup dengan membaca register berikutnya.
|
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
}
}
|
Posting