חיישן טמפרטורה I2C LM75
עקרון הפעלה
El IC LM75 הוא א חיישן טמפרטורת פער פס מוליך למחצה סיליקון.
במוליכים למחצה, ה להקה אסורה זהו אזור האנרגיה של האלקטרונים שלא ניתן להגדיל עם עלייה בשדה החשמלי מכיוון שאין מצבים זמינים לנוע מהר יותר. זֶה להקה אסורה נכלל בין ה פס הערכיות (אנרגיה נמוכה יותר) וה להקת הולכה (אנרגיה גבוהה יותר). עירור תרמי (העלייה בטמפרטורה, למטרות בהן אנו מעוניינים) יכולה לגרום לכמה אלקטרונים לרכוש מספיק אנרגיה כדי לעבור לתוך להקת הולכה.
כפי שהוסבר במאמר הקודם על מדידת טמפרטורה אלקטרונית, במתכות, למרות שמספר הנשאים אינו תלוי בטמפרטורה (כל האלקטרונים זמינים תמיד), הניידות שלהם מושפעת מהטמפרטורה, כך שההתנגדות במתכות עולה עם הטמפרטורה עקב ירידת מהירות האלקטרונים בגלל הגידול שלהם ערבול תרמי ופיזור האלקטרונים שהוא מייצר.
במקרה של מוליכים למחצה, בשל נוכחותו של זה להקה אסורה מספר הנשאים אכן תלוי בטמפרטורה (תלוי ב הפצת פרמי-דיראק) מה שגורם למוליכות לעלות עם הטמפרטורה. במוליכים למחצה, עליית הטמפרטורה מייצרת עלייה בהתנגדות אך גם מייצרת עלייה (נוספת) במוליכות.
ل חיישני טמפרטורת פער פסי מוליכים למחצה סיליקון, כמו במקרה של ה-LM75, פועלים על פי עיקרון זה, ומאפשרים לקבוע את הטמפרטורה על ידי כימות השפעתה על המתח בדיודת סיליקון.
רכיבי חומרה LM75
ל-LM75 יש גם א ממיר אנלוגי-דיגיטלי על ידי אפנון Sigma-Delta שאחראי על קבלת הערך המספרי (דיגיטלי) של הטמפרטורה, ערך שנשמר לאחר מכן (כל 100 אלפיות השנייה) באחד הרגיסטרים שלו שממנו ניתן לקרוא אותו דרך האפיק I2C.
בנוסף לרגיסטר המכיל את הטמפרטורה הנמדדת, ל-LM75 יש רגיסטר בו ניתן לאחסן טמפרטורה מקסימלית וכן משווה המסוגל להפיק אות אם הטמפרטורה הנמדדת עולה על זו המאוחסנת באוגר שני זה. על מנת לא להפעיל שוב את האזהרה עד שהטמפרטורה הנמדדת תרד מתחת לרמה מסוימת, אוגר שלישי מאפשר אחסון ערך לטמפרטורה של היסטרזיס.
התצורה של פעולת LM75 מאוחסנת בפנקס רביעי שבאמצעותו נקבעים התנאים שבהם נוצרת האזהרה, אופן הפעלת אות אזהרה זה (מצב הפרעה או מצב השוואה) וכן הפעלת המכשיר (מצב) פעולה רגילה או צריכה נמוכה) בין שאר הפרמטרים.
מפרט טכני ויישום של LM75
טווח הטמפרטורות שה-LM75 מסוגל למדוד משתנה מ-55 °C ל-+125 °C והרזולוציה המספרית היא 0.125 °C אם כי הדיוק הוא רק ±2 °C במקרה הטוב, כאשר הטמפרטורה היא בין – 25 מעלות צלזיוס ו-+100 מעלות צלזיוס ודיוק של 3 מעלות צלזיוס ± עם הטמפרטורות הקיצוניות ביותר, בין 55 מעלות צלזיוס ל-125 מעלות צלזיוס.
היישום (חומרה) של ה-LM75 במעגל הוא מאוד פשוט, הוא לא צריך יותר רכיבים מהנגדים משיכה דל אוטובוס I2C ויכול להיות מופעל עם מתח בין 2,8 וולט ל-5,5 וולט באותו אוטובוס I2C ניתן לארגן עד שמונה מדי חום LM75 על ידי קביעת כתובתם עם שלושת הפינים A0, A1 ו-A2 ברמה גבוהה או נמוכה, כמקובל במקרים אלה.
מצד שני, השימוש ב-LM75 כבדיקה אינו נוח בגלל החבילות שבהן הוא מוצג, TSSOP (TSSOP8) או SEC (SO8) והוא משמש בדרך כלל למדידת טמפרטורת הסביבה או למדידת הטמפרטורה של רכיבים המסודרים בסביבת PCB בו ממוקם מדחום LM75.
בעת האתחול, ה-LM75 מוגדר לזהות טמפרטורה מקסימלית של +80°C, טמפרטורה של היסטרזיס של +75 מעלות צלזיוס ומצב הפעולה של המשווה, כלומר המצב המחקה את פעולת התרמוסטט: הוא מפעיל את האזהרה כאשר הטמפרטורה המקסימלית מושגת ורק אם היא יורדת מתחת ל- היסטרזיס מחדש את ההודעה.
ניצול ה-LM75 ממיקרו-בקר דרך אפיק I2C
בזכות השימוש ב- אוטובוס I2C הפעולה של ה-LM75 פשוטה מאוד, פשוט גשו לכתובת שהוא תופס באוטובוס כדי לאחסן או לקרוא את התצורה ולקבלת ערך הטמפרטורה הנמדדת.
הכתובת I2C הבסיס של ה-LM75 הוא 0B01001XXX והוא מתווסף, כפי שהוסבר לעיל, על ידי שלושת סיביות הכתובת האחרונות המוגדרות על ידי חומרה עם פינים A0, A1 ו-A2 גבוה (ערך אחד) או נמוך (ערך אפס).
ה-LM75 כמדחום
האוגר שמאחסן את הטמפרטורה האחרונה שנמדדה (TEMP) נמצא בכתובת 0x00, אוגר התצורה (CONF) נמצא בכתובת 0x01, האוגר שמאחסן את הטמפרטורה של היסטרזיס בכתובת 0x02 ולטמפרטורה המקסימלית או היתרה (TOS) יש כתובת 0x03. מלבד הטמפרטורה הנוכחית (TEMP), כולם מתפקדים כקריאה וכתיבה.
שימוש בכמה דוגמאות קוד שפותחו עבור Arduino (שהפכה לכמעט התייחסות אוניברסלית) ניתן להבהיר עוד יותר את פעולת ה-LM75. הדוגמה השימושית הבסיסית ביותר היא להשתמש ב-LM75 כמדחום על ידי קריאת התיעוד של הטמפרטורה האחרונה שנמדדה.
|
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
}
|
התהליך הוא הרגיל בעבודה עם מכשיר I2C:
- הוסף את הספרייה I2C לקוד עם
#include <Wire.h> - אתחל את הספרייה I2C באמצעות
Wire.begin(); - גש לחיישן הטמפרטורה LM75 באמצעות
Wire.beginTransmission(DIRECCION_LM75) - שלח את הכתובת של הרישום אליו ניגש באמצעות
Wire.write(REGISTRO) - שחרר את אוטובוס I2C עם
Wire.endTransmission() - גישה מחדש ל-LM75
- בקש את ערך הרישום עם
Wire.requestFrom(DIRECCION,CANTIDAD) - ודא שהנתונים התקבלו באמצעות
Wire.available() - קרא את הערך המבוקש
Wire.read()(כמה פעמים שהבתים מרכיבים את זה) - למרות שזה לא חיוני, בסיום, שחרר את אוטובוס I2C
בנוסף לפרוטוקול הרגיל להשגה או אחסון מידע ביומני המכשיר באמצעות אוטובוס I2C, כדי לנצל את הנתונים שה-LM75 מספק, יש צורך לשקול את הפורמט שבו הוא מייצג באופן פנימי את הטמפרטורה.
השגת הערך המאוחסן ברשומות הטמפרטורה של LM75
בשורה 22 של הקוד בדוגמה הקודמת ניתן לראות כיצד לטעון את המידע המאוחסן על ידי שלושת אוגרי הטמפרטורה של ה-LM75. הוא משתמש בשני בתים (16 סיביות) שמתוכם רק 11 הביטים המשמעותיים ביותר תקפים. כדי לקרוא את הטמפרטורה כמספר שלם (עם הסימן מקודד ב השלמה של שניים) הבייט המשמעותי ביותר נטען ראשון למשתנה int de Arduino והוא מסובב 8 ביטים שמאלה, ומשאיר אותו בחלק המשמעותי ביותר של int. לאחר מכן קוראים את הביט השני ומוסיפים למשתנה. int עם פעולת OR
פרשנות של ערך הטמפרטורה הטעון של LM75
בשורה 24 ניתן לראות כיצד לפרש את ערך הטמפרטורה. קודם כל, יש צורך לחלק ב-32 כמספר שלם (לסובב את 11 הסיביות הרלוונטיות מבלי לאבד את הסימן) ולחלק ב-8, שזה מספר ה"צעדים" שבהם מיוצגת הטמפרטורה (אוקטבות של מעלה) כדי לקבל ערך סוג float עם הספרות העשרוניות המתאימות. מאז המהדרים (כולל ה שרשרת כלים de Arduino) לייעל את חלוקת המספרים השלמים ב-32, אין צורך לשמר את הסימן ו"ידנית" לסובב את הביטים, מכיוון שהפעולה אינה מהירה יותר (באופן ניכר).
ודא קליטת נתונים מאפיק I2C
למרות שהקוד הקודם יעבוד ללא בעיות למרות שלא וידאו אם הנתונים המבוקשים על ידי המכשיר הגיעו. אוטובוס I2C, הדבר הכי אורתודוקסי (ומומלץ) הוא לחכות שהנתונים יגיעו במספר המתאים. מכיוון שמהירות השידור וההתנגדות לשגיאות הן די והותר, מקובל למצוא קוד שבו הנתונים פשוט מתבקשים וקראו ללא המתנה. עבור הדוגמאות כדאי לעשות זאת כך מאחר והן אינן מסיחות את הדעת מהכוונה העיקרית אך עבור קוד הייצור רצוי לעשות זאת כפי שמוצע בנקודה השביעית של הרשימה של תהליך התקשורת I2C. הקוד בדוגמה הבאה מדגיש את השינויים המומלצים לשימוש ב-LM75 בשלב הניצול.
|
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
}
|
הגדר את פעולת ה-LM75
התצורה הבסיסית ביותר של ה-LM75 מורכבת מקביעת הטמפרטורה המקסימלית כדי ליצור את האזהרה ואת היסטרזיס, שיקבע מתי הוא מושבת וניתן לחזור עליו. כדי להגדיר ערכים אלה, אתה רק צריך לאחסן אותם באוגרים המתאימים.
כמו שיא הטמפרטורה הנוכחי, הטמפרטורה המקסימלית (אזהרה) ו היסטרזיס הם משתמשים בשני בתים אבל בניגוד לראשון הם לא מחשיבים 11 סיביות (שמינית ממעלה) אלא 9 (חצי מעלה) כך שגם אם ערך קטן יותר היה מאוחסן, רק מרווחים של רזולוציה זו ייחשבו.
|
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
}
}
}
|
מכיוון שבקוד הקודם רק תצורת הטמפרטורות הקשורות לאזהרה משתנה, שאר הפעולה תואמת את תצורת ברירת המחדל.
בתצורת ברירת מחדל זו ישנם שני מאפיינים שרלוונטיים, ראשית מצב האזהרה, כברירת מחדל מה שנקרא "מצב תרמוסטט" אשר מורכב מהפעלת האזהרה כאשר הטמפרטורה המקסימלית (או האזהרה) הושגה ולא ביטולה עד להורדה ל- טמפרטורה של היסטרזיס. החלופה היא "מצב פסיקה", שבו האות מופעל כאשר הוא חורג מהמקסימום או כאשר הוא מגיע לערך נמוך מזה של היסטרזיס ומאופס על ידי קריאת כל רשומה, בדרך כלל הטמפרטורה הנוכחית.
המאפיין השני הוא שאות האזהרה מופעל ברמה נמוכה, כלומר, פין מערכת ההפעלה נמצא ברמה גבוהה עד שמגיעים לטמפרטורת האזהרה המקסימלית. מכיוון שהקוטביות של אות האזהרה (הרמה שבה הוא מופעל) ניתנת להגדרה, בכמה התקנות פשוטות יספיק להשתמש באות זה (חומרה) כדי לנצל את ה-LM75, למשל, חיבור או ניתוק מאוורר כאשר המערכת מגיע לטמפרטורה מסוימת.
כמו כן, ניתן להגדיר את פעולת ה-LM75 כך שלא יתריע מיד לאחר הגעה לטמפרטורת האזהרה אלא יעשה זאת לאחר מספר תקריות. התנהגות זו שימושית מאוד כאשר עובדים במגבלת הטמפרטורה או כאשר היא משתנה במהירות רבה. ניתן להגדיר את ה-LM75 להתריע לאחר חריגה מהטמפרטורה המקסימלית פעם אחת, פעמיים, ארבע או שש פעמים.
באוגר התצורה יש גם קצת לנטרל ("לכבות") את ה-LM75 ולהיכנס למצב צריכה נמוכה, שיוצאים ממנו על ידי שינוי ביט זה שוב או פשוט בעת קריאת האוגר הבא.
|
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
}
}
|
לפרסם תגובה