Práctica No. 2 Sensores de Temperatura

UPIITA-IPN Práctica No. 2.Sensores de Temperatura 1) Hernández Cruz Luis Eduardo 2) Salinas Soria Erik 3) Suárez Alvarado César Omar Resumen Materia: Sensores Automotrices y Acondicionadores de Señal Número de Equipo: 4 Nombre del Equipo: Mechanics and Electronics Grupo: 7SM1 En la siguiente práctica se lleva a cabo la aplicación del uso de amplificadores operacionales en la aplicación de instrumentos de medición para dispositivos electromecánicos, termodinámicos, maquinaria. En este caso uno ve como cada dispositivo necesita algún tipo de sistema de control, desde compuertas lógicas, contadores binarios, convertidores analógicodigital y micro controladores. La principal función es advertirle al usuario, los cambios que se detecten en su zona de ubicación. Los sensores, varían según su necesidad, en algunos casos, son interruptores de estado sólido, como las resistencias LDR, en caso de sensar el lux o la candela, los termistores NTC o PTC para los cambios de temperatura que llegasen a sensar. Las mediciones son necesarias para comprender los comportamientos físicos, que deseamos analizar y comprender para así poder interpretarlos. Por ello los sensores son las herramientas dentro de los dispositivos de control que nos ayudan a entender lo que deseamos que una maquina realice, sin la necesidad de que haya un operador. Abstract A thermistor is a type of resistor whose resistance varies significantly with temperature, more so than in standard resistors. The word is a portmanteau of thermal and resistor. Thermistors are widely used as inrush current limiters, temperature sensors, self-resetting overcurrent protectors, and self-regulating heating elements. A thermocouple is a temperature-measuring device consisting of two dissimilar conductors that contact each other at one or more spots. It produces a voltage when the temperature of one of the spots differs from the reference temperature at other parts of the circuit. Thermocouples are a widely used type of temperature sensor for measurement and control and can also convert a temperature gradient into electricity. Commercial thermocouples are inexpensive, interchangeable, are supplied with standard connectors, and can measure a wide range of temperatures. In contrast to most other methods of temperature measurement, thermocouples are self-powered and require no external form of excitation. The main limitation with thermocouples is accuracy; system errors of less than one degree Celsius (°C) can be difficult to achieve. The silicon bandgap temperature sensor is an extremely common form of temperature sensor (thermometer) used in electronic equipment. Its main advantage is that it can be included in a silicon integrated circuit at very low cost. The principle of the sensor is that the forward voltage of a silicon diode is temperature-dependent. Introducción Los sensores de temperatura, en una manera son las herramientas dentro de los sistemas de control que nos ayudan a entender cómo es que funcionan dentro de los dispositivos, dado que si uno se adentrara dentro de un sistema de control y este no tuviera alguna manera de entender los datos que se envían, la mayoría de entrada analógica que por pulsos de voltaje regula un control que necesitan cierto proceso de potencia, filtrado y conversión de señal de un voltaje a un pulso digital de lenguaje binario. El uso de sensores de temperatura depende del uso que uno le otorgue, de cierta manera uno como diseñador, así como el tipo que se desee utilizar, no solo por gusto del diseñador, sino para poder satisfacer la necesidad que se necesite cubrir. Termistor Un termistor es una resistencia que varía según la temperatura que detecta, sin embargo el detectar cambios es difícil de medir. Los termistores están fabricados de manera que su resistencia cambia drásticamente de tal manera que puedan cambiar de 100 ohmios o más por grado centígrado. Hay dos tipos de sensores dentro de los termistores en este caso son los NTC y los tipo PTC, en los primeros, a medida que aumenta la temperatura, decrece su resistencia; en los segundos a medida que aumenta la temperatura en este caso aumenta la resistencia. Se suele usar los sensores NTC para fijar patrones de temperatura, los PTC son usados en ciertos casos para protección de los circuitos ahogando la corriente y protegiendo el sobrecalentamiento de los circuitos. Para medir el valor de la resistencia de un termistor, dado el voltaje que otorgue, este nos indicara la temperatura en donde nos encontramos. Cuando se detecta, el voltaje medido, está aumentando, podremos deducir, por la lógica de la Ley de Ohm, que la resistencia del Termistor NTC está disminuyendo y, por tanto, que la temperatura se encuentra en un claro aumento y viceversa (si el voltaje disminuye es porque la temperatura ha descendido). La relación exacta entre el voltaje medido y la resistencia del termistor se puede calcular de la misma manera que ya vimos en el caso de las fotorresistencias, mediante el desarrollo matemático: Vmed = (Rpull/(Rpull+Rtermistor)).Vfuente La relación entre la resistencia y la temperatura en este tipo de sensores no es lineal sino exponencial. Dicha relación cumple con la fórmula siguiente: Donde A y B son constantes que dependen del resistor. Esas constantes que nos da el fabricante son: A: El valor resistivo para una temperatura en concreto (en nuestro caso 2800Ω para 25º). B: La Beta (Temperatura característica del material entre 2000K y 4000K). Cuando nos especifican estos datos, podemos utilizar la ecuación anterior para calcular la resistencia en una temperatura en particular: La característica tensión-intensidad (V/I) de un resistor NTC presenta un carácter peculiar, ya que cuando las corrientes que lo atraviesan son pequeñas, el consumo de potencia (R I2) será demasiado pequeño para registrar aumentos apreciables de temperatura, o lo que es igual, descensos en su resistencia óhmica; en esta parte de la característica la relación tensión-intensidad será prácticamente lineal y en consecuencia cumplirá la ley de Ohm. Pero si seguimos aumentando la tensión aplicada a la NTC, se llegará a un valor de intensidad en que la potencia consumida provocará aumentos de temperatura suficientemente grandes como para que la resistencia disminuya apreciablemente, incrementándose la intensidad hasta que se establezca el equilibrio térmico. Para evitar esto, la mejor manera de conectarlo a nuestro microcontrolador es mediante un divisor de tensión donde Vout va a ser prácticamente lineal. LM35 El LM35 es un sensor de temperatura integrado de precisión, cuya tensión de salida es linealmente proporcional a temperatura en ºC (grados centígrados). El LM35 por lo tanto tiene una ventaja sobre los sensores de temperatura lineal calibrada en grados Kelvin: que el usuario no está obligado a restar una gran tensión constante para obtener grados centígrados. El LM35 no requiere ninguna calibración externa o ajuste para proporcionar una precisión típica de ± 1.4 ºC a temperatura ambiente y ± 3.4 ºC a lo largo de su rango de temperatura (de -55 a 150 ºC). El dispositivo se ajusta y calibra durante el proceso de producción. La baja impedancia de salida, la salida lineal y la precisa calibración inherente, permiten la creación de circuitos de lectura o control especialmente sencillos. El LM35 puede funcionar con alimentación simple o alimentación doble (+ y -). Requiere sólo 60 µA para alimentarse, y bajo factor de auto-calentamiento, menos de 0,1 ºC en aire estático. El LM35 está preparado para trabajar en una gama de temperaturas que abarca desde los- 55 ºC bajo cero a 150 ºC, mientras que el LM35C está preparado para trabajar entre -40 ºC y 110 ºC (con mayor precisión). Características: Calibrado directamente (Centígrados) en grados Celsius del robot o bien para analizar las temperaturas en el transcurso de un trayecto de exploración. Para hacernos un termómetro lo único que necesitamos es un voltímetro bien calibrado y en la escala correcta para que nos muestre el voltaje equivalente a temperatura. Podemos conectarlo a un conversor Analógico/Digital y tratar la medida digitalmente, almacenarla o procesarla con un µControlador o sim. Termopar Un termopar es un dispositivo de estado sólido que se utiliza para convertir la energía en voltaje. Consta de dos metales diferentes empalmados en una juntura. Pueden utilizarse como materiales para la fabricación de termopares, tales como: hierro y constantano, cobre y constantano o antimonio y bismuto. Los termopares se emplean como sensores de temperatura e instrumentos semejantes a los termómetros denominados pirómetros. En un pirómetro, el voltaje producido por un termopar origina que una corriente circule a través de un medidor eléctrico, el cual se calibra para indicar directamente el valor de la temperatura. Un termopar puede colocarse en un horno; cuando aumenta la temperatura en el horno, también aumenta el voltaje que se genera en el termopar. En consecuencia pasa más corriente por el medidor. En tal caso, el medidor indica el aumento de corriente como una temperatura mayor. Con los pirómetros se puede medir con mucha precisión, temperaturas que van desde 2700 hasta 10,800ºF (1,500 a 6,000ºC). Un termopar no mide temperaturas absolutas, sino la diferencia de temperatura entre el extremo caliente y el extremo frío. Este efecto termoeléctrico hace posible la medición de temperatura mediante un termopar. Tipos de Termopar. Factor de escala lineal de +10 mV / ºC 0,5ºC de precisión a +25 ºC Rango de trabajo: -55 ºC a +150 ºC Apropiado para aplicaciones remotas Bajo costo Funciona con alimentaciones entre 4V y 30V Menos de 60 µA de consumo Bajo auto-calentamiento (0,08 ºC en aire estático) Baja impedancia de salida, 0,1W para cargas de 1mA. El sensor de temperatura puede usarse para compensar un dispositivo de medida sensible a la temperatura ambiente, refrigerar partes delicadas Aunque existen más tipos de termopar estos son los más comunes. 5 12.3 12.5 8.2 12.3 10.5 13.4 13 13. Incoloy 800.68 8.9 11.Caracterización del Termistor NTC.9 12.4 12.5 13. TF 220°C.3 10 10 10 10 10 10 10 10 15 15 15 15 15 15 15 15 20 20 20 20 20 20 20 20 24 24 24 24 24 24 24 24 30 30 30 30 30 30 Generalmente los termopares se fabrican con tubos protectores o termopozos. Acero inoxidable 304 o 316.8 11. Estos pueden ser con conexiones a proceso roscadas NPT milimétricas o bridadas.9 10. Hasteloy. Cerámica silma.93 8. Así como los límites de error: Protección para Termopares.72 10. esta es con el fin de proteger los alambres del termopar contra las atmósferas corrosivas y las altas presiones.63 10.1 11.62 10.6 13.1 13 12. Inconel 600 y 625. TERMISTOR Resistencia Temperatura 13.4 11.76 8.7 11.5 11. .64 10. Hierro negro.3 11 11.45 8. Cerámica aluminia pura.8 13.7 12.2 8.68 10. Carburo de silicio.69 10.5 10. 146 0.82 6.25 0.352 0.359 0.5 6.315 0.73 4.162 0.193 0.198 0.6 30 30 35 35 35 35 35 35 35 35 40 40 40 40 40 40 40 40 45 45 45 45 45 45 45 45 50 50 50 50 50 50 50 50 50 Caracterización del sensor LM35.64 5.377 0.336 0.63 5.15 0.88 5.79 5.38 5.2 0.141 0.86 5.169 0.61 4.13 0.79 8.132 Temperatura 10 10 0.45 5.33 0.92 4.234 0.86 5.185 0.225 0.35 0.98 6.255 0.56 4.196 0.368 0.266 0.328 0.375 10 10 10 10 10 10 15 15 15 15 15 15 15 15 20 20 20 20 20 20 20 20 24 24 24 24 24 24 24 24 30 30 30 30 30 30 30 30 35 35 35 35 .194 0.238 0.273 0.268 0.71 5.94 5. LM35 Voltaje 0.74 6.178 0.79 4.44 6.41 6.69 5.229 0.23 0.246 0.344 0.292 0.66 4.225 0.66 5.137 0.173 0.95 4.39 4.281 0.363 0.5 5.8.84 4.27 5.57 6.74 5.37 5.67 6.252 0.155 0. 512 0.442 0.494 0.449 0.25 0.422 0.432 0.2 0.52 0.0.05 0 13.525 35 35 35 35 40 40 40 40 40 40 40 40 45 45 45 45 45 45 45 45 50 50 50 50 50 50 50 50 50 Caracterización Gráfica de los sensores a trabajar.4 0.5 0.473 0.45 0.523 0.522 0.6 0.1 Voltaje 0 0 20 40 60 LM35DZ 0.381 0.489 0.3 .15 0.415 0.517 0.396 0.1 0.4 0.491 0.2 0.3 0.3 0.526 0.485 0.478 0. LM35DZ: LM35DZ 0.483 0.469 0.8 25 Voltaje 33 32.427 0.461 0.454 0.43 0.35 0.395 0.499 0.5 0.439 0. . se tiene que realizar un diseño de un circuito que tenga la tarea de sensar los cambios de temperatura de un sensor de temperatura.. este amplificara la ganancia del Cuando se aplica un cambio de temperatura este lo sensa y genera un aumento en el voltaje que se le deja llegar al galvanómetro que no es más que una herramienta de medición la cual. así desplazando la aguja y censando la temperatura desde el LM35. el cual se linealizara y dará una precisión del cambio de temperatura en el galvanómetro. Termistor NTC 15 10 5 0 0 20 40 60 Resistencia Termistor NTC 15 10 5 0 13. va mostrando los cambios de temperatura. con escala de grados Celsius. el cual tenga la capacidad de dar una lectura en la cual este muestre los cambios.Termistor NTC: sensor LM35. Desarrollo 1. Se usara un sensor LM35.3 43 Aquí se ve como está configurado tanto el sensor y el galvanómetro que da una temperatura aproximada de alrededor. mediante un galvanómetro. En este diseño se muestra un galvanómetro que sirve como escala de medición en grados Celsius. con el uso de amplificadores operacionales. de este dispositivo.8 25 33 Resistencia 32.En el primer desarrollo. Para claro ejemplo se tiene el manejo. de unos 31oC. el cual mostrara la leyenda de los cambios de temperatura. que se amplificara para tener una mayor ganancia y poder calibrar nuestro Galvanómetro. del sensor y este será llevado a un proceso matemático el cual convertirá las variaciones de voltaje en pulsos. en una LCD. al final obtendremos los valores los cuales imprimiremos en nuestra leyenda dentro de la LCD. el cual procesara la señal analógica. determina el incremento de la temperatura con la relación al incremento del voltaje de salida del sensor. estos son tratados como datos dentro del microprocesador. dado que el LCD. se tiene que realizar un diseño de un sensor de temperatura. 7 8 9 10 11 12 13 14 D0 D1 D2 D3 D4 D5 D6 D7 VCC1 GND1 AREF .. ubicada en el Pin A0. LCD1 LM016L GND ARDUINO MEGA RESET VCC1 GND1 P13 P12 P11 P10 P9 P8 P7 P6 P5 P4 P3 A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 TX RX TX1 RX1 TX2 RX2 TX3 RX3 CCT001 VSS VDD VEE RS RW E 4 5 6 1K POWER L 1K 2. y 1 U3 27.0 2 VOUT 3 LM35 (SS)D53 (SCK) D52 (MOSI)D51 (MISO)D50 D49 D48 D47 D46 D45 D44 D43 D42 D41 D40 D39 D38 D37 D36 D35 D34 D33 D32 D31 D30 D29 D28 D27 D26 D25 D24 D23 D22 1 2 3 RV1 10K SDA SCL La imagen muestra la conexión de la placa Arduino. dado los grados Celsius y Fahrenheit. será la muestra de un circuito digital. Se muestra que el dispositivo deberá ser conectado a un microcontrolador Arduino. en el cual el voltaje de salida del sensor. del sensor y este será llevado a un proceso matemático el cual convertirá las variaciones de voltaje en pulsos. y sus componentes los cuales muestran como la señal de entrada del LM35.Aquí se muestra un claro ejemplo de cómo funciona este dispositivo. envía la señal detectada por el sensor. Se muestra que el dispositivo deberá ser conectado a un microcontrolador Arduino. la temperatura que sensa y los cambios que podría llegar a sensar. y estos son tratados como datos dentro del microprocesador. el cual procesara la señal analógica.En el segundo diseño. al final obtendremos los valores los cuales imprimiremos en nuestra leyenda dentro de la LCD. // Convierte el valor a temperatura tempC = (5.2). digitalWrite(13. lcd.1). lcd. // Definimos la entrada en pin A0 char Grados = 'º'. Serial. LiquidCrystal lcd(12.5.0).begin(9600). void setup() { // Abre puerto serial y lo configura a 9600 bps Serial. //Definimos la pantalla LCD float tempC. lcd.print(" C"). lcd. pinMode(13. // Espera cinco segundo para repetir el loop . //Mostramos los grados en la pantalla LCD lcd.2).setCursor(0. int tempPin = 0.11.4. Serial.println("F"). float tempF.print("Grados: "). // Envia el dato al puerto serial Serial. Serial.8*tempC)+32.println("C").print(Grados).print(tempF).print(tempC). lcd.print(tempC).print(Grados).setCursor(0.0 * tempC * 100. Serial.0.//Con este comando decimos en que línea queremos escribir lcd. lcd.h>//Incluir esta librería para poder usar el lcd. Serial. //Grados Farenheitt tempF = (1.3.Ahora se mostrara el código: #include <LiquidCrystal.print(tempF).0)/1024.OUTPUT).begin(16. HIGH).print("Grados: ").print("Grados: "). //Activamos la retroiluminación } void loop() { // Lee el valor desde el sensor tempC = analogRead(tempPin).print(" F"). lcd. Serial. . domicilios. se tiene un diseño. se analizan los pulsos analógicos que son transformados en bits y mostrados en la pantalla. activara la conversión de señales en la cual mandara pulsos cuadrados digitales. } En si el diseño es en parte una aplicación de un sensor. se realiza algo parecido al diseño anterior. En ello se muestra el cambio de temperatura de alrededor de 24. de controlador Analógico-Digital.4oC.5oC a una temperatura de más de 107. el cual sería de apoyo y uso en casos como el de hogares. los cuales a veces necesitan de un sistema de medición en este caso de temperatura. En esta imagen se muestra el proyecto ya realizado. el cual la entrada de una señal analógica de poco voltaje. Dado que su precisión es una de las mejores en este tipo de dispositivos. oficinas etc. cada uno de los leds dentro de los vummers de una escala de 10oC a 100 oC. hasta que se llegue al máximo establecido por el proveedor. los cuales encenderán. Pero también sensa los cambios de temperatura. En este diseño.. Al final se muestra su eficiencia para sensar temperaturas menores a la del ambiente del lugar. pero en vez de enviar una leyenda de cuando cambia el valor de la temperatura se encenderá una de las líneas de los vummers.Para este diseño.delay(1000). al pasarle una llama sobre su superficie. 3. se maneja la precisión de ser un buen sensor de temperatura ambiente. realizando los cálculos correspondientes. Para que se enciendan cada uno de las líneas de los vummers analizaremos el código usado: 11 12 13 14 15 16 17 18 19 20 R4 R5 R6 R8 R7 R10 R11 R9 R13 R12 220 220 220 220 220 220 220 220 220 220 . conectado a 10 salidas de Arduino.GND ARDUINO MEGA RESET VCC1 GND1 P13 P12 P11 P10 P9 P8 P7 P6 P5 P4 P3 A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 TX RX TX1 RX1 TX2 RX2 TX3 RX3 CCT001 VCC1 GND1 AREF (SS)D53 (SCK) D52 (MOSI)D51 (MISO)D50 D49 D48 D47 D46 D45 D44 D43 D42 D41 D40 D39 D38 D37 D36 D35 D34 D33 D32 D31 D30 D29 D28 D27 D26 D25 D24 D23 D22 GND ARDUINO MEGA RESET VCC1 GND1 P13 P12 P11 P10 P9 P8 P7 P6 P5 P4 P3 A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 TX RX TX1 RX1 TX2 RX2 TX3 RX3 CCT001 VCC1 GND1 AREF (SS)D53 (SCK) D52 (MOSI)D51 (MISO)D50 D49 D48 D47 D46 D45 D44 D43 D42 D41 D40 D39 D38 D37 D36 D35 D34 D33 D32 D31 D30 D29 D28 D27 D26 D25 D24 D23 D22 1K POWER L 1K 1K POWER L 1K 1 U3 1 U3 10 9 8 7 6 5 4 3 2 1 27. las cuales mediante una sentencia de condición encenderán cada una de las líneas del vummer.0 2 10 9 8 7 6 5 4 3 2 1 100. las cuales se encenderán al incremento de la temperatura y se apagaran al decremento de la misma.0 2 VOUT U2 LED-BARGRAPH-RED VOUT U2 LED-BARGRAPH-RED 3 LM35 3 LM35 11 12 13 14 15 16 17 18 19 20 R4 R5 R6 R8 R7 R10 R11 R9 R13 R12 220 220 220 220 220 220 220 220 220 220 SDA SCL SDA SCL Aquí se muestra la simulación del proyecto el cual cuenta con un vummer. char Grados = 'º'. //Escala de Avisos int escala = 5.h> float tempC. OUTPUT). OUTPUT). //Declaramos pines de salida pinMode(pinLed1. int pinLed2 = 9. pinMode(pinLed3. OUTPUT). int pinLed6 = 13. pinMode(pinLed5. int pinLed4 = 11. OUTPUT). int pinLed3 = 10. pinMode(pinLed4. int pinLed5 = 12. pinMode(pinLed2. } void loop() { // Lee el valor desde el sensor tempC = analogRead(tempPin). OUTPUT). pinMode(PotPin. OUTPUT). int pinLed9 = 16. // Definimos la entrada en pin A0 int PotPin = 1.#include <math.0. OUTPUT). pinMode(pinLed6. pinMode(pinLed9. OUTPUT). OUTPUT). int pinLed8 = 15. pinMode(pinLed10. int pinLed7 = 14. int pinLed10 = 17. // Salida para el Galvanómetro int outputValue = 0. pinMode(pinLed8. const int analogOutPin = 9. OUTPUT). //Variable para la temperatura de disparo double tempMin = 0. //Y los pines de entrada pinMode(tempPin.begin(9600). pinMode(pinLed7. // valor de salida para PWM Galvanómetro(analog out) //Pines para los LED int pinLed1 = 8. void setup() { // Abre puerto serial y lo configura a 9600 bps Serial. INPUT). . float tempF. int tempPin = 0. INPUT). // Cambia el valor de salida de voltaje para el Galvanómetro: analogWrite(tempPin. Serial. digitalWrite(pinLed6. Serial. Serial.println("-----------------------------------------------"). //Ahora las comparaciones para las salidas if(tempC < tempMin) { digitalWrite(pinLed1.print(tempF). outputValue). digitalWrite(pinLed4. . Serial.8*tempC)+32. 1023. 255). Serial. -100. Serial. Serial.print(Grados). HIGH).// Convierte el valor a temperatura tempC = (5.println("C"). LOW). LOW).0.0)/1024. Serial.println("F"). 1023. //Y lanzamos el ajuste establecido vía serie Serial.println(). Serial. LOW).print(tempC). 0. digitalWrite(pinLed3. Serial.print(tempMin). //Y lo dividimos entre 10 para darle un decimal tempMin = tempMin/10. // Envia el dato al puerto serial Serial.0 * tempC * 100. //Primero leemos el potenciómetro tempMin = analogRead(PotPin).print(Grados). LOW). 0. 800).println(). Serial. digitalWrite(pinLed2.println(" GRADOS CELSIUS"). //Lo mapeamos a valores de -100 a 800 tempMin = map (tempMin.println("-----------------------------------------------").print("Grados: "). 0. LOW). digitalWrite(pinLed5. // Mapea el rango de temperatura del galvanómetro de acuerdo al voltaje otorgado: outputValue = map(tempPin. Serial. //Grados Fahrenheit tempF = (1.print("AJUSTE DE TEMPERATURA MINIMA A "). LOW). digitalWrite(pinLed2. LOW). LOW). HIGH). } else if (((tempC<=(tempMin+(escala*3)+5))&(tempC>tempMin+escala+5))) { digitalWrite(pinLed1. LOW). digitalWrite(pinLed6. HIGH). HIGH). LOW). digitalWrite(pinLed5. } else if (((tempC <= (tempMin + escala + 5)) & (tempC > tempMin))) { digitalWrite(pinLed1. digitalWrite(pinLed5. digitalWrite(pinLed7. LOW). HIGH). LOW). LOW). HIGH). digitalWrite(pinLed10. LOW). digitalWrite(pinLed9. LOW). digitalWrite(pinLed9. digitalWrite(pinLed9. LOW). digitalWrite(pinLed8. HIGH).digitalWrite(pinLed7. HIGH). digitalWrite(pinLed4. LOW). digitalWrite(pinLed7. digitalWrite(pinLed2. LOW). HIGH). LOW). digitalWrite(pinLed10. digitalWrite(pinLed8. LOW). digitalWrite(pinLed8. } else if ((tempC<=(tempMin+(escala*7)+5))&(tempC>tempMin+(escala*5)+5)) { digitalWrite(pinLed1. LOW). LOW). digitalWrite(pinLed6. LOW). digitalWrite(pinLed6. } else if ((tempC<=(tempMin+(escala*5)+5))&(tempC>tempMin+(escala*3)+5)) { digitalWrite(pinLed1. digitalWrite(pinLed5. digitalWrite(pinLed10. digitalWrite(pinLed4. digitalWrite(pinLed9. LOW). digitalWrite(pinLed4. digitalWrite(pinLed3. LOW). LOW). LOW). digitalWrite(pinLed3. digitalWrite(pinLed2. LOW). LOW). digitalWrite(pinLed3. . digitalWrite(pinLed8. digitalWrite(pinLed7. HIGH). HIGH). digitalWrite(pinLed10. LOW). HIGH). digitalWrite(pinLed7. digitalWrite(pinLed10. LOW). HIGH). digitalWrite(pinLed10. HIGH). digitalWrite(pinLed9. . digitalWrite(pinLed9. digitalWrite(pinLed5. HIGH). digitalWrite(pinLed3. HIGH). digitalWrite(pinLed8. HIGH). LOW). HIGH). HIGH). HIGH). HIGH). LOW). HIGH). digitalWrite(pinLed6. digitalWrite(pinLed5. digitalWrite(pinLed6. digitalWrite(pinLed4. HIGH). digitalWrite(pinLed9. digitalWrite(pinLed7. HIGH). HIGH). LOW). LOW). HIGH). HIGH).digitalWrite(pinLed2. digitalWrite(pinLed8. digitalWrite(pinLed5. digitalWrite(pinLed9. LOW). HIGH). digitalWrite(pinLed3. HIGH). digitalWrite(pinLed5. LOW). digitalWrite(pinLed7. HIGH). digitalWrite(pinLed2. LOW). digitalWrite(pinLed2. digitalWrite(pinLed3. HIGH). digitalWrite(pinLed4. digitalWrite(pinLed4. digitalWrite(pinLed8. LOW). digitalWrite(pinLed8. HIGH). digitalWrite(pinLed6. LOW). LOW). LOW). HIGH). } else if ((tempC<=(tempMin+(escala*11)+5))&(tempC>tempMin+(escala*9)+5)) { digitalWrite(pinLed1. digitalWrite(pinLed4. digitalWrite(pinLed7. HIGH). digitalWrite(pinLed6. } else if ((tempC<=(tempMin+(escala*9)+5))&(tempC>tempMin+(escala*7)+5)) { digitalWrite(pinLed1. HIGH). LOW). HIGH). digitalWrite(pinLed2. } else if ((tempC<=(tempMin+(escala*13)+5))&(tempC>tempMin+(escala*11)+5)) { digitalWrite(pinLed1. digitalWrite(pinLed3. digitalWrite(pinLed10. digitalWrite(pinLed8. } else if (tempC > (tempMin + (escala*17)+5)) { digitalWrite(pinLed1. digitalWrite(pinLed8. Dado la condición se muestra como solo se encienden tres líneas. HIGH). digitalWrite(pinLed4. } Se analiza que se necesita de una sentencia “if”. HIGH). HIGH). HIGH). digitalWrite(pinLed7. digitalWrite(pinLed10. LOW). HIGH). digitalWrite(pinLed9. HIGH). HIGH). para cumplir las condiciones. digitalWrite(pinLed6. digitalWrite(pinLed3. HIGH). HIGH). HIGH). digitalWrite(pinLed10. LOW). . HIGH). HIGH). digitalWrite(pinLed5. digitalWrite(pinLed7. digitalWrite(pinLed6. a su vez este encenderá cada una de las barras del vummer.digitalWrite(pinLed10. HIGH). digitalWrite(pinLed5. } //Un pequeño delay para no volver loco al puerto serie delay(2500). HIGH). digitalWrite(pinLed9. HIGH). } else if ((tempC<=(tempMin+(escala*15)+5))&(tempC>tempMin+(escala*13)+5)) { digitalWrite(pinLed1. digitalWrite(pinLed2. HIGH). dado que apenas sensa el cambio de temperatura cumpliendo la condición de encenderse tres líneas si la temperatura es mayor a 20oC. HIGH). HIGH). digitalWrite(pinLed2. HIGH). digitalWrite(pinLed4. digitalWrite(pinLed3. el cual que se mantenga el agua entre 20oC y 30oC. siempre y cuando cumpla las condición de encenderse cuando la temperatura del líquido o agua no este entre los 20oC y no mayor a 30oC.En ésta imagen se muestra como rebasa los 100oC. previamente establecido. debido que el dispositivo lleva una alimentación de 127v de C. el cual contiene el uso de un amplificador. Para este caso se tiene que usar un calefactor que lleve una etapa de potencia. Para el desarrollo de este proyecto. GND ARDUINO MEGA RESET VCC1 GND1 P13 P12 P11 P10 P9 P8 P7 P6 P5 P4 P3 A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 TX RX TX1 RX1 TX2 RX2 TX3 RX3 CCT001 VCC1 GND1 AREF (SS)D53 (SCK) D52 (MOSI)D51 (MISO)D50 D49 D48 D47 D46 D45 D44 D43 D42 D41 D40 D39 D38 D37 D36 D35 D34 D33 D32 D31 D30 D29 D28 D27 D26 D25 D24 D23 D22 1K POWER L Aquí se tiene el caso contrario. 1K D3 DIODE RL1 12V L1 12V 1 U3 Q1 BC547 L1(2) 23. en este caso a una temperatura menor a los 10oC. y no deje que aumente o disminuya. esta situación cumple la condición del cambio de temperatura al ser censada.A la cual si no se aterriza bien podría dañar nuestros componentes. dado que podrá ser usado para establecer cierto confort en alguna aplicación.-Diseñar un circuito el cual haga que funcione un calefactor de agua.-Diseñar un circuito el cual active un ventilador al alcanzar una temperatura de 50oC los cuales servirán como señal de activación para encender un ventilador de 12v.0 2 VOUT 3 LM35 SDA SCL En esta imagen se muestra cómo es que se configuro nuestro diseño y el cual cumple la condición de cerrar el circuito de potencia. Por ello para entenderlo mejor se analizara el código: . 4. en el cual se llega a la temperatura mínima. la temperatura dentro de los rangos. la pequeña flama que indica que se han alcanzado una temperatura previamente mencionada. 5. personal. de un amplificador operacional y un transistor el cual sirve como interruptor de estado sólido. se cuenta con el apoyo. el cual sirve como un calefactor para distintos usos. cumpliendo la condición de solo encender una línea de los vummers. } else{ digitalWrite(6.0)/1024. // Envia el dato al puerto serial Serial. //Grados Farenheitt tempF = (1. lcd.begin(16. pinMode(13.0 * tempC * 100. Serial. digitalWrite(13.OUTPUT).begin(9600).print(tempC). HIGH).0.print("Grados: "). int tempPin = 0.float tempC. Serial. Serial. //Activamos la retroiluminación } void loop() { // Lee el valor desde el sensor tempC = analogRead(tempPin). if(20<tempC&&tempC<30) { digitalWrite(6.println("F"). void setup() { // Abre puerto serial y lo configura a 9600 bps Serial. // Convierte el valor a temperatura tempC = (5.2).println("C"). float tempF.LOW).print(Grados).8*tempC)+32. } delay(1000). Serial. } .print(Grados). Serial.HIGH).print(tempF). Serial. // Definimos la entrada en pin A0 char Grados = 'º'. cada minuto. dado a su composición física. que se trabajó con un sensor. . para calentar el agua. se obtiene el uso del sensor NTC. se debe establecer que la temperatura del fluido. La última parte de esta práctica consistió en la implementación de los circuitos anteriormente descritos pero ahora con el uso de un Termistor NTC. Si se observa de manera atenta se muestra la ebullición del agua al calentarse la resistencia. dentro del rango de una temperatura promedio de 20oC. lo cual no genera que cierre el circuito de potencia. debido al aumento de la corriente sobre la misma. con la temperatura que llega a sensar y a variar a la vez. en este caso agua es de unos 2 a 3 grados Celsius menor a la ambiente. la cual se ve el funcionamiento de cómo lo enciende y empieza a conducir corriente sobre una resistencia eléctrica. 6. cuando este llegue a superar la temperatura de 30oC se apagara.Aquí se muestra una imagen.7oC. la cual generar un incremento exponencial de alrededor de unos 5. el cual se deberá linealizar. lo que genera que se encienda el calefactor.. el cual ya está linealizado la variación de voltaje. Aquí se muestra en reposo a una temperatura ambiente menor a 30oC. dado que este rompe la barrera de la mínima de 20oC. Se muestra como se genera la calefacción del líquido en el recipiente. los cuales se deberán dar una medición en el galvanómetro. indicando una temperatura aproximada. Dado.Para este diseño. una leyenda con los posibles cambios de temperatura que llegue a sentir. 1K RV1 RV2 10K 10K +tc 25. en el microcontrolador el cual reproducirá. con lo cual este llega a sensar la temperatura de la habitación. el cual nos ayudara amplificar el voltaje y su ganancia en la señal que envíe nuestro Termistor NTC.00 RT2 KTY81 R4 10k SDA SCL Aquí está el código. (ese día la temperatura promedio ambiente era alrededor de unos 12oC) estableciendo una lectura de 14oC en el ambiente de la habitación.Para linealizar al Termistor NTC. LCD1 LM016L GND ARDUINO MEGA RESET VCC1 GND1 P13 P12 P11 P10 P9 P8 P7 P6 P5 P4 P3 A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 TX RX TX1 RX1 TX2 RX2 TX3 RX3 CCT001 VSS VDD VEE RS RW E 4 5 6 D0 D1 D2 D3 D4 D5 D6 D7 7 8 9 10 11 12 13 14 VCC1 GND1 AREF (SS)D53 (SCK) D52 (MOSI)D51 (MISO)D50 D49 D48 D47 D46 D45 D44 D43 D42 D41 D40 D39 D38 D37 D36 D35 D34 D33 D32 D31 D30 D29 D28 D27 D26 D25 D24 D23 D22 1K POWER L Aquí se muestra al diseño. y se conectara una resistencia de 220Ω. de uso genérico LM358. de los cuales regularan la señal del Termistor de un valor de 10kΩ. el cual indique las temperaturas. y muestre la temperatura que sensa alrededor. la cual conectada en serie para que la señal no se llegue a perder en la caída de potencial. en funcionamiento. se debe conectar dos resistencias en paralelo de valores aproximados a 10kΩ y 4. este llega a sensar la temperatura y para elevar su aguja este tiende a reducir la resistividad misma de los materiales que lo compone. Para este caso. el cual muestra cómo se debe linealizar el código. con un medidor patrón es mínimo ya que es casi instantánea la variabilidad de su resistencia así como sus cambio. 7. el cual amplifica y genera la variación del voltaje sobre el cual se muestra en el galvanómetro. se debe de usar un sensor NTC.. para que muestre una leyenda en una LCD. dentro del microprocesador: 1 2 3 .En este diseño. se tiene que el NTC mandara señales analógicas de variación de voltaje. que se tiene al acercarse la flama de un mechero. en este caso el retraso. tanto en grados Celsius y grados Fahrenheit. la cual se hacen ajustes dentro de los códigos.7kΩ. Ya en esta imagen muestra el incremento. con las resistencias pull-up. Se tiene el uso de un Opamp. //Y lo dividimos entre 10 para darle un decimal tempMin = tempMin/10.0. pinMode(13. Serial.11. // [ohm] Variable para NTC en ohms float TempK = 0.h #include <math. 800). //Y lanzamos el ajuste establecido vía serie Serial. digitalWrite(13. // [K] Temperatura de referencia en Kelvin float Vout = 0.0. -100.print("AJUSTE DE TEMPERATURA MINIMA A "). //Activamos la retroiluminación } void loop() { //Primero leemos el potenciómetro tempMin = analogRead(PotPin).0.print(tempMin).h> #include <LiquidCrystal. //Definimos la pantalla LCD //Pines para las entradas analógicas int tempPin = 0.5.0. lcd. //Variable para la temperatura de disparo double tempMin = 0. // [K] Temperatura salida en Kelvin float TempC = 0.h> //Incluir esta librería para poder usar el lcd LiquidCrystal lcd(12.OUTPUT).//Añadimos la librería math.2). // [ºC] Temperatura salida en Celsius float tempF. 0. char Grados = 'º'.println().15.3.2). HIGH).0.0.0. // [V] Tensión alimentación del divisor float Rfija = 200. void setup() { // Abre puerto serial y lo configura a 9600 bps Serial.begin(9600).4. Serial. // [V] Variable para almacenar Vout float Rntc = 0. 1023. .println("-----------------------------------------------"). // [K] Parámetro Beta de NTC float T0 = 293. //Lo mapeamos a valores de -100 a 800 tempMin = map (tempMin. Serial. // [ohm] Resistencia fija del divisor float R25 = 2800. int PotPin = 1.0. //Datos para las ecuaciones float Vin = 5. // [ohm] Valor de NTC a 25ºC float Beta = 3977.begin(16. Serial.print("Grados: ").print("LA TEMPERATURA DE LA NTC ES DE "). Serial.print(tempF).print(TempC). Serial. Serial.0). //Y ahora la pasamos a Celsius TempC = TempK-273. //Y por último la temperatura en Kelvin TempK = Beta/(log(Rntc/R25)+(Beta/T0)).Serial.8*TempC)+32.15. //Y lo mostramos por puerto serie Serial. Serial.print(Grados). //Y ahora calculamos la Temperatura //Primero la Vout del divisor Vout=(Vin/1024)*(analogRead(tempPin)).print(" F").print("Grados: ").print(TempC).println(). } . delay(1500). lcd. //Mostramos los grados en la pantalla LCD lcd. lcd. //Grados Fahrenheit tempF = (1.setCursor(0. Serial. lcd. lcd.println("C"). Serial.println("F").print(Grados). lcd.setCursor(0.print(tempF). Serial.1). Serial.print(" C").//Con este comando decimos en que línea queremos escribir lcd.println(" GRADOS CELSIUS").println(). //Ahora la resistencia de la NTC Rntc=(Vout*Rfija)/(Vin-Vout).println("-----------------------------------------------"). lcd. lo cual mantiene la relación de que sigue la relación de disminuir la temperatura del sensor. con el cual se desempeña la leyenda del cual muestra los cambios de temperatura. los leds del vummer de un rango de 10oC a 100oC. Dado la precisión de este tipo de sensor. Si uno llegara a variar la temperatura. y si así es la condición que se cumple al haberlo linealizado este deberá dar una condición de precisión. este respondería de manera rápida. Pero a la vez este es capaz de realizar los cambios de temperatura. . el cual se ira de una señal analógica de variación de voltaje a una digital la cual active mediante pulsos.Al concluir el programa el resultado que se tiene es la temperatura censada. en la cual la entrada deberá ser un sensor NTC. cuando se le introduce a una superficie que tiene menor temperatura. por el Termistor NTC. Esta tendrá la capacidad de descender.. no tiene mucho problema con empatar con el medidor patrón para determinar si este se encuentra bien calibrado. 8. a solo 10oC. cambiando los valores de las temperaturas a su alrededor. la cual muestra cómo llega a cambiar los valores descendiendo de casi 90oC. hasta casi 0oC.Se deberá realizar un diseño de un circuito Analógico-Digital. y a la salida deberá estar un vummer. tanto en grados Celsius y Fahrenheit. Como los circuitos anteriores se muestra como reaccionara el sensor a los cambios de temperatura. en el caso de la imagen muestra como la temperatura debe variara entre los 25 a 29oC. de este diseño. de tal manera que este valla encendiendo. con el configurar el vummer.00 KTY81 R16 10k SDA SCL 11 12 13 14 15 16 17 18 19 20 RT2 R4 R5 R6 R8 R7 R10 R11 R9 R13 R12 220 220 220 220 220 220 220 220 220 220 Aquí se empieza.GND ARDUINO MEGA RESET VCC1 GND1 P13 P12 P11 P10 P9 P8 P7 P6 P5 P4 P3 A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 TX RX TX1 RX1 TX2 RX2 TX3 RX3 CCT001 VCC1 GND1 AREF (SS)D53 (SCK) D52 (MOSI)D51 (MISO)D50 D49 D48 D47 D46 D45 D44 D43 D42 D41 D40 D39 D38 D37 D36 D35 D34 D33 D32 D31 D30 D29 D28 D27 D26 D25 D24 D23 D22 1K POWER L 1K RV2 10 9 8 7 6 5 4 3 2 1 U2 LED-BARGRAPH-RED 10K +tc 25. al cambiar la temperatura. ya que este va a sensar el cambio en su alrededor y cada luz que se enciende indica un incremento. cada una de las líneas. esto es fácil de deducir gracias a que el código que muestra solo tres líneas en el vummer. El código. es el siguiente: . //Datos para las ecuaciones float Vin = 5. int pinLed8 = 21. int pinLed3 = 16. // [ºC] float tempF.0. // [K] Parámetro Beta de NTC float T0 = 293. // [ohm] Variable para NTC en ohms float TempK = 0. // [ohm] Valor de NTC a 25ºC float Beta = 3977.h #include <math. int pinLed7 = 20. // [K] Temperatura de referencia en Kelvin float Vout = 0.0. // [K] float TempC = 0. int pinLed10 = 23. //Pines para las entradas analógicas int tempPin = 0. int pinLed5 = 18.//Añadimos la librería math. const int analogOutPin = 9. int pinLed6 = 19. // valor de salida para PWM Galvanómetro(analog out) //Escala de Avisos int escala = 5.begin(9600). char Grados = 'º'.15. int pinLed9 = 22. int pinLed4 = 17. // [ohm] Resistencia fija del divisor float R25 = 2800.h> //Pines para los LED int pinLed1 = 14.0. //Variable para la temperatura de disparo double tempMin = 0. int PotPin = 2.0. // Salida para el Galvanómetro int outputValue = 0. // [V] Variable para almacenar Vout float Rntc = 0. void setup() { //Comenzamos la comunicación puerto serie Serial.0. int pinLed2 = 15. // [V] Tensión alimentación del divisor float Rfija = 200.0. Temperatura salida en Kelvin Temperatura salida en Celsius .0.0. pinMode(pinLed3. pinMode(pinLed8. pinMode(pinLed9.println("-----------------------------------------------"). Serial. INPUT). Serial.print("AJUSTE DE TEMPERATURA MINIMA A "). Serial. OUTPUT).println(). OUTPUT). 0.println(). INPUT).println("-----------------------------------------------"). pinMode(PotPin. OUTPUT). OUTPUT). Serial. //Lo mapeamos a valores de -100 a 800 tempMin = map (tempMin. OUTPUT). Serial. -100. pinMode(pinLed5. Serial.print(tempMin). //Y lanzamos el ajuste establecido vía serie Serial. pinMode(pinLed7. pinMode(pinLed2. //Ahora la resistencia de la NTC Rntc=(Vout*Rfija)/(Vin-Vout). OUTPUT). 1023. 800). OUTPUT). pinMode(pinLed6. //Y por último la temperatura en Kelvin TempK = Beta/(log(Rntc/R25)+(Beta/T0)).//Declaramos pines de salida pinMode(pinLed1. pinMode(pinLed4. OUTPUT). . OUTPUT).println(" GRADOS CELSIUS"). //Y los pines de entrada pinMode(tempPin. pinMode(pinLed10. //Y ahora calculamos la Temperatura //Primero la Vout del divisor Vout=(Vin/1024)*(analogRead(tempPin)). OUTPUT). } void loop() { //Primero leemos el potenciómetro tempMin = analogRead(PotPin). //Y lo dividimos entre 10 para darle un decimal tempMin = tempMin/10. LOW).print(Grados). digitalWrite(pinLed7. . 1023. LOW). Serial. digitalWrite(pinLed9. digitalWrite(pinLed5.//Y ahora la pasamos a Celsius TempC = TempK-273. digitalWrite(pinLed8. outputValue).println("F"). LOW). Serial. LOW). Serial. digitalWrite(pinLed3. } else if (((TempC <= (tempMin + (escala*2) + 5)) & (TempC > tempMin + escala))) { digitalWrite(pinLed1. LOW). LOW). LOW). 0. digitalWrite(pinLed10. // map it to the range of the analog out: outputValue = map(tempPin. LOW). LOW). digitalWrite(pinLed5. digitalWrite(pinLed4. //Ahora las comparaciones para las salidas if(TempC < tempMin + escala) { digitalWrite(pinLed1.print(tempF). LOW).print(TempC). Serial. HIGH). LOW). HIGH). digitalWrite(pinLed6.8*TempC)+32.15. digitalWrite(pinLed7.print("LA TEMPERATURA DE LA NTC ES DE ").println("C"). Serial. HIGH). //Grados Farenheitt tempF = (1. LOW). LOW). LOW). digitalWrite(pinLed2. Serial.println(). digitalWrite(pinLed2. 255). digitalWrite(pinLed9. //Y lo mostramos por puerto serie Serial.print(Grados). 0. digitalWrite(pinLed8. digitalWrite(pinLed3. digitalWrite(pinLed6. LOW). LOW). // change the analog out value: analogWrite(tempPin. digitalWrite(pinLed4. Serial. digitalWrite(pinLed4. digitalWrite(pinLed7. HIGH). LOW). digitalWrite(pinLed6. digitalWrite(pinLed9. digitalWrite(pinLed6. LOW). HIGH). digitalWrite(pinLed8. digitalWrite(pinLed8. LOW). LOW). digitalWrite(pinLed4. } else if ((TempC<=(tempMin+(escala*6)+5))&(TempC>tempMin+(escala*4)+5)) { digitalWrite(pinLed1. HIGH). digitalWrite(pinLed9. digitalWrite(pinLed7. digitalWrite(pinLed10. } else if ((TempC<=(tempMin+(escala*10)+5))&(TempC>tempMin+(escala*8)+5)) { digitalWrite(pinLed1. LOW). digitalWrite(pinLed7. LOW). digitalWrite(pinLed5. LOW). digitalWrite(pinLed3. } else if (((TempC<=(tempMin+(escala*4)+5))&(TempC>tempMin+(escala*2)+5))) { digitalWrite(pinLed1. LOW). LOW). digitalWrite(pinLed4. digitalWrite(pinLed3. digitalWrite(pinLed2. digitalWrite(pinLed10. LOW). digitalWrite(pinLed3. HIGH). digitalWrite(pinLed2. } else if ((TempC<=(tempMin+(escala*8)+5))&(TempC>tempMin+(escala*6)+5)) { digitalWrite(pinLed1. HIGH). digitalWrite(pinLed5. digitalWrite(pinLed10. . digitalWrite(pinLed2. LOW). LOW). LOW). digitalWrite(pinLed5. LOW). digitalWrite(pinLed9. digitalWrite(pinLed6. HIGH). HIGH). LOW). digitalWrite(pinLed2. digitalWrite(pinLed3. LOW). LOW). HIGH).digitalWrite(pinLed10. digitalWrite(pinLed8. HIGH). digitalWrite(pinLed4. HIGH). HIGH). LOW). HIGH). HIGH). LOW). HIGH). HIGH). HIGH). digitalWrite(pinLed5. LOW). LOW). digitalWrite(pinLed8. digitalWrite(pinLed7. HIGH). digitalWrite(pinLed6.digitalWrite(pinLed5. LOW). digitalWrite(pinLed7. HIGH). HIGH). digitalWrite(pinLed8. digitalWrite(pinLed7. digitalWrite(pinLed10. HIGH). digitalWrite(pinLed9. digitalWrite(pinLed7. digitalWrite(pinLed10. HIGH). digitalWrite(pinLed5. LOW). HIGH). } else if ((TempC<=(tempMin+(escala*16)+5))&(TempC>tempMin+(escala*14)+5)) { digitalWrite(pinLed1. HIGH). } else if (TempC > (tempMin + (escala*17)+10)) . digitalWrite(pinLed6. HIGH). digitalWrite(pinLed9. } else if ((TempC<=(tempMin+(escala*14)+5))&(TempC>tempMin+(escala*12)+5)) { digitalWrite(pinLed1. LOW). digitalWrite(pinLed10. HIGH). HIGH). HIGH). digitalWrite(pinLed4. digitalWrite(pinLed8. LOW). LOW). digitalWrite(pinLed10. HIGH). digitalWrite(pinLed8. HIGH). digitalWrite(pinLed6. digitalWrite(pinLed4. HIGH). } else if ((TempC<=(tempMin+(escala*12)+5))&(TempC>tempMin+(escala*10)+5)) { digitalWrite(pinLed1. HIGH). digitalWrite(pinLed3. HIGH). digitalWrite(pinLed4. HIGH). HIGH). LOW). digitalWrite(pinLed3. digitalWrite(pinLed9. digitalWrite(pinLed6. HIGH). digitalWrite(pinLed5. digitalWrite(pinLed9. digitalWrite(pinLed2. digitalWrite(pinLed2. HIGH). digitalWrite(pinLed2. digitalWrite(pinLed3. HIGH). LOW). HIGH). HIGH). HIGH). HIGH). HIGH). LOW). digitalWrite(pinLed4. HIGH). . } Por ello. HIGH). este puede. regresar rápidamente a su estado original o disminuir la temperatura anterior o cercana previamente al incremento de la temperatura de la llama. una de las condiciones es que tenga una temperatura mínima. que sirva de barrera. digitalWrite(pinLed10. HIGH). } //Un pequeño delay para no volver loco al puerto serie delay(2500). HIGH). digitalWrite(pinLed3. A su vez muestra el decremento de la temperatura censada por el NTC. la condición de los cambios de temperatura. y se enciendan las líneas de los vummers. En el caso de la imagen inferior se llega a temperaturas menores a los 10oC. digitalWrite(pinLed6. A su vez cuando deja de sensar los incrementos de temperatura. HIGH). se llegan a presentar. el cual puede medir temperaturas por lo menor a lo establecido en el limitador. digitalWrite(pinLed2. digitalWrite(pinLed8. digitalWrite(pinLed5. digitalWrite(pinLed7. para que este empiece a ejercer cambios. HIGH). HIGH). digitalWrite(pinLed9. HIGH). HIGH).{ digitalWrite(pinLed1. HIGH). 9. este se encenderá. Para entender su funcionamiento. mientras no llegue a esa temperatura no encenderá.. el cual al llegar la temperatura de 50oC. En este diseño. para su funcionamiento: .En el siguiente diseño se tiene un sensor NTC. se encenderá. Pero. el cual deberá activar un ventilador al alcanzar una temperatura de 50oC la cual activara el ventilador y al caer esa temperatura se activara su estado de reposo. y activara al ventilador. debemos marcar el código en Arduino. al cumplir la condición. se hace una sentencia que cumpla la condición de encender un ventilador a 50oC. Serial. void setup() { Serial. int PotPin = 3.15. Serial.println(). tempMin = map (tempMin.0. Serial.0. // [ohm] Resistencia fija del divisor float R25 = 2800. // [ºC] char Grados = 'º'. float Vin = 5.println(). // [V] Variable para almacenar Vout float Rntc = 0. pinMode(6.0. TempC = TempK-273. 800). tempMin = tempMin/10. TempK = Beta/(log(Rntc/R25)+(Beta/T0)).println(" GRADOS CELSIUS"). // [K] Temperatura de referencia en Kelvin float Vout = 0. -100. // [K] Parámetro Beta de NTC float T0 = 293. Vout=(Vin/1024)*(analogRead(tempPin)).print(tempMin). if(TempC>50) { digitalWrite(6. // [K] float TempC = 0. Serial. Serial. Serial.println("-----------------------------------------------"). } Temperatura salida en Kelvin Temperatura salida en Celsius .0. Rntc=(Vout*Rfija)/(Vin-Vout).h> int tempPin = 0. double tempMin = 0. // [ohm] Variable para NTC en ohms float TempK = 0.0. // [V] Tensión alimentación del divisor float Rfija = 200.0.HIGH).0. } void loop() { tempMin = analogRead(PotPin). 1023.0.println("-----------------------------------------------"). Serial. 0.#include <math.print("AJUSTE DE TEMPERATURA MINIMA A ").OUTPUT).begin(9600). // [ohm] Valor de NTC a 25ºC float Beta = 3977.15. . Como en el caso anterior del sensor LM35. Serial. se debe encender cuando no este en la temperatura de 20oC y mantenerse así.print(Grados). el cual se tiene en el código: . } Serial.00 RT2 KTY81 R16 10k SDA SCL 10. dado que podrá ser usado para establecer cierto confort en Para comprender el funcionamiento de nuestro diseño. debemos mostrar el código. personal. Serial.println(). se vuelve apagar. el cual activara el calentador al romper ese rango. GND ARDUINO MEGA RESET VCC1 GND1 P13 P12 P11 P10 P9 P8 P7 P6 P5 P4 P3 A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 TX RX TX1 RX1 TX2 RX2 TX3 RX3 CCT001 VCC1 GND1 AREF (SS)D53 (SCK) D52 (MOSI)D51 (MISO)D50 D49 D48 D47 D46 D45 D44 D43 D42 D41 D40 D39 D38 D37 D36 D35 D34 D33 D32 D31 D30 D29 D28 D27 D26 D25 D24 D23 D22 1K POWER L 1K D3 DIODE RL1 12V L1 12V Q1 BC547 RV2 10K +tc 25. previamente establecido.LOW). pero no sobrepasando los 30oC. la temperatura dentro de los rangos. delay(1000). alguna aplicación.print(TempC). Serial. cumpliendo con el objetivo y la condición de trabajo. del microcontrolador. el cual que se mantenga el agua entre 20oC y 30oC.else { digitalWrite(6.Diseñar un circuito el cual haga que funcione un calefactor de agua.println("C"). } Al caer la condición de una temperatura menor de 50oC. y no deje que aumente o disminuya.print("LA TEMPERATURA DE LA NTC ES DE "). Serial. El sensor a utilizar en este caso deberá ser un termistor NTC. TempC = TempK-273.println().0. void setup() { Serial.HIGH). Vout=(Vin/1024)*(analogRead(tempPin)). if(20<TempC&&TempC<30) { digitalWrite(26. float Vin = 5. -100. // [ºC] char Grados = 'º'.OUTPUT). Serial. TempK = Beta/(log(Rntc/R25)+(Beta/T0)). // [V] Variable para almacenar Vout float Rntc = 0. Serial.println().0. // [ohm] Variable para NTC en ohms float TempK = 0.println(" GRADOS CELSIUS").0.#include <math. int PotPin = 4. Serial. Rntc=(Vout*Rfija)/(Vin-Vout).print(tempMin). } void loop() { tempMin = analogRead(PotPin).println("-----------------------------------------------"). Serial. 0.begin(9600). // [ohm] Resistencia fija del divisor float R25 = 2800. // [K] Parámetro Beta de NTC float T0 = 293. // [K] Temperatura de referencia en Kelvin float Vout = 0. tempMin = tempMin/10. tempMin = map (tempMin. // [V] Tensión alimentación del divisor float Rfija = 200. Serial.println("-----------------------------------------------"). pinMode(6.0. Serial.0. // [K] float TempC = 0.0. // [ohm] Valor de NTC a 25ºC float Beta = 3977.0.h> int tempPin = 0. 800). Serial. 1023. double tempMin = 0. } Temperatura salida en Kelvin Temperatura salida en Celsius .15.print("AJUSTE DE TEMPERATURA MINIMA A ").0.15. print(Grados).  Por último. en que se llega a controlar un proceso de automatización como base de los parámetros. sensores termopares. el uso de sensores. con circuitos integrados.print(TempC). Por ello si por alguna razón no se llega a cumplir la condición de que el agua se encuentre mayor a 20oC o menor a 30oC.LOW). los cuales nos ayudaran a realizar un circuito más eficiente el cual nos hacía más preciso en su utilización. a su vez este ejercicio. este deberá de encender al calefactor. Serial. sensar o determinar como el rango. fue de gran parte de cómo entender cada uno de ellos. debido a la facilidad que hay dentro de su programación. } Para ello el control del calefactor. debemos entender que se conecta a un circuito de potencia. que debe realizar un cambio o establecer una condición. o como los cambios de voltaje indican un cambio al afectar la temperatura que sensa el circuito LM35. la caracterización de los sensores.  Se usó el microcontrolador Arduino.println("C"). para cambiar el estado del que se encuentra. Serial. aplico previos conocimientos de prácticas anteriores. es una de las maneras modernas. como ser usados de medida patrón en la práctica. por ello fue de gran ayuda ya que el diseñar un prototipo. delay(1000).println(). en las cuales se muestran en la linealización del NTC.else{ digitalWrite(26.print("LA TEMPERATURA DE LA NTC ES DE "). } Serial. Serial. COMENTARIOS:  Para esta práctica. como sistema de control para algunos de los diseños. y como los . Serial. llegan a ser los más precisos. en los cuales estos son determinados como los rango que se desean controlar o tener una información de lo que se trata de medir. el cual al cumplirse la condición encenderá al circuito. mx/termopares. Hernández Cruz Luis Eduardo Se concluye que el uso de los sensores de temperatura. José Manuel Ruiz de Marcos 1ª Edición Editorial McGraw-Hill Págs. Suárez Alvarado César Omar BIBLIOGRAFÍA:  “Sensores y acondicionadores de Señal” Autor: Ramón Pallás Areny 4ª Edición Editorial Marcombo Págs. si se quiere linealidad y facilidad de uso un LM35. se observó el problema con una diferencia de alrededor de 3 grados en el circuito analógico con su salida en un Galvanómetro. que si uno quiere velocidad en el cambio de la temperatura es un NTC el que se debe usar. tal fue el caso del sensor LM35DZ que resultó ser el más rápido de estos. nos ayuda a comprender cómo es que cada componente electrónico se comporta de manera diferente. Se tiene el inconveniente de tener que hacer una linealización para poder adecuar el funcionamiento correcto del Termistor NTC.termokew. costo y materiales. en cuanto a precisión entre uno y otro es de alrededor de 0. Consultadas: Capitulo 7.com/2011/12/componentesel-sensor-ntc/ Título: Sensor LM35 http://electronica. Consultadas: Tema 14. ya que el uso del termistor se complicó ya que al linealizar el dispositivo se tuvo un error mayor con respecto al patrón de medida utilizado. De los sensores utilizados el LM35 resulto más eficaz a pesar de tener una respuesta lenta.arduteka.CONCLUSIONES: De los sensores de temperatura empleados en esta práctica se comprobaron las características de cada uno de ellos. 423-428  Electrónica Analógica para Ingenieros Autor: Jorge Pleite Guerra.x-robotics.005 milésimas de unidad Celsius.com/sensores.webcindario. lo que los hace diferentes en cuanto a tiempo de reacción o velocidad con la que censan los cambios de temperatura. 17 327-351 Cibergrafía: Título: Sensores NTC http://www. observando una gran diferencia respecto a su velocidad de respuesta.com/componentes/ lm35.htm http://www.4 160-165  Arduino: Curso práctico de formación Autor: Óscar Torrente Artero 1a Edición Editorial Alfaomega Págs.php . Salinas Soria Erik Armando Existen diferentes tipos de sensores de temperatura con características específicas de acuerdo a su aplicación. Consultadas: Capitulo 2. Ricardo Vergaz Benito.htm#LM35 Título: Termopares http://www.