Título del artículo

Soncco Hancco, Leonel Nombres y apellidos Nombres y apellidos

lsonccoh@unsa.edu.pe e-mail e-mail
 Resumen — Este documento electrónico es una plantilla que define los componentes de su trabajo
(título, texto, encabezados, etc.) en su hoja de estilos.

Palabras clave — DST –> DISPOSITIVO SENSOR DE TEMPERATURA (TERMOPAR)

uCP-> micro controlador PIC-16F877A
PCB -> Printed Circuit Board (placa de circuito impreso)
ADC -> conversión análoga digital

I. INTRODUCCIÓN
Una de las magnitudes físicas más medidas es la temperatura y su uso es amplio y diverso. Por
ende la medición de temperatura es importante sea cual sea el ámbito de su aplicación.
El fin de este informe es realizar un sensor de temperatura con el DST.
Los sensores de temperatura usan diferentes efectos físicos para convertir la temperatura en una
magnitud eléctrica y su funcionamiento se basa en el cambio de su resistencia eléctrica al cambiar
la temperatura.
El DST, típicamente suele estar formado por el elemento sensor, el encapsulado que lo envuelve y
que está rellena de un material muy conductor de la temperatura, para que los cambios se
transmitan rápidamente al elemento sensor y del cable al que se conectarán el equipo electrónico.
En este caso el sensor de temperatura ira conectado a uCP que interpretara la entrada de voltaje
suministrada por el sensor, y este ira conectado una pantalla LCD de 16X2, y allí se mostrara la
temperatura actual; con acción de un teclado 4x4 se podrá cambiar la magnitud en Rankin, Celsius y
Fahrenheit mostrándola en el LCD.
El programa para el uCP estará hecho en CCSCOMPILER (lenguaje C), la simulación del sensor de
temperatura en PROTEUS, y el diseño esquemático y PCB del circuito completo en AUTODESK-
EAGLE.

II. DESCRIPCION

DESCRIPCIÓN DEL DIAGRAMA ESQUEMÁTICO USADO EN LA SIMULACIÓN

De la imagen1 se muestra el esquemático usado en la simulación. Se ha repartido en 3 cuadros para
la imagen para hacer más sencilla su descripción.
El cuadro naranja muestra la parte del DST, al DST se conecta un arreglo de amplificador
diferencial, puesto que la salida del DST está en miliVolts (mV), se hace un arreglo de amplificador
con una ganancia de 100, la salida del DST estará conectado al pin 9 del uCP que es una de las
entradas análogas de este. Para que el uCP calcule con el voltaje de entrada la temperatura testeada y
la muestre el LCD.
Posteriormente el uCP interpreta la señal entregada por el DST. Calcula con único dato el voltaje del
pin 9 en análogo 6 del puerto A, hace una conversión ADC, y lo reserva en una variable.
El cuadro azul, representa una entrada y/o interrupción mediante un teclado 4x4 , con sus resistencias
pullup , para el muestreo de temperatura en los pines 19-20-21-22-27-28-29-30 en el puerto D del
uCP, primeramente solo envía 3 señales digitales, dados solo por 3 teclas; la tecla ‘8’ será la tecla ‘2’
y la tecla ‘-‘ será la tecla ‘C’; la tecla 2 representara la interrupción hacia el uCP para que el valor
calculado por este se recalcule debidamente para que se guarde en otra variable en unidad de
temperatura de grados Celsius, la tecla 6 lo hará para otra variable en unidad de temperatura Rankin,
y la tecla C para otra variable en grados Fahrenheit .
Por último, el recuadro amarillo representa el periférico de salida de uCP para nuestro código de
programación en los pines 33-34-35-37-38-39-40 en el puerto B del uCP, donde el LCD 16X2
conectado a estos pines mostrará la temperatura, por acción del teclado, ya sea en °C, R o °F. El
arreglo de estos pines está dado por un bus de control de 4 bits para el LCD 16X2, este arreglo está el
datasheet del mismo, donde:
 Pines de alimentación:

Vss-> ground o tierra para el LCD

VDD-> Voltaje de alimentación del LCD
V0-> Ajuste de contraste para LCD
 Pines de control:

RS-> registro de la selección de señal (pin 33)

Cuando RS es 0 el dato presente en el bus pertenece a un registro de
control/instrucción. y cuando RS es 1 el dato presente en el bus de datos pertenece a
un registro de datos o un carácter.
R/W-> selección para read/write (pin 34)
Corresponde al pin de Escritura(0) o de Lectura(1). Nos permite escribir un dato en la
pantalla o leer un dato desde la pantalla.
E-> operación de read o write (pin 35)
Si E(0) esto quiere decir que el LCD no esta activado para recibir datos, pero si E(1)
se encuentra activo y podemos escribir o leer desde el LCD.
 Pines de Bus de datos:

D4-D7-> entrada para los 4 bits mas significativos del bus de datos
Todo ello es lo que hace nuestro medidor de magnitudes físicas.

 imagen1
DESCRIPCION DE LA PLACA EN C

DESCRIPCIÓN DE LA PLACA CONSTRUIDA

De la imagen2 se muestra el diagrama esquemático completo de la placa.
El recuadro morado nos muestra la parte de alimentación hacia nuestro circuito; contiene un
regulador LM7805, el cual tiene un voltaje de entrada y de salida, el voltaje de entrada es la
alimentación general de nuestro circuito, su voltaje de salida es la alimentación para nuestro uCP,
este arreglo está dado por el fabricante del lm7805 en su datasheet recomienda poner estos
capacitores para evitar oscilaciones de alta frecuencia generadas internamente en el 7805, el diodo
para protección de polarización inversa debido a que ocasionalmente, el voltaje de entrada al
regulador puede colapsar más rápido que el voltaje de salida, si el voltaje de salida es superior a
aproximadamente 7 V, la unión emisor-base del elemento serie-pase (interna o externa) podría
descomponerse y dañarse. Para evitar esto, se puede usar un shunt de diodo de protección,
aportándonos un voltaje de salida de 5 volts.
Le sigue el circuito oscilador para el uCP, que le indica a que frecuencia trabajar, condicionándonos
incluso el programa.
Seguidamente esta el arreglo del LCD, donde se tiene un potenciómetro de 5k ohm para regular el
contraste del LCD, y la conexión de su ánodo a alimentación con una resistencia de 330ohms,
proporcionado también el la hoja de datos del fabricante.
Luego se tiene el teclado, periférico de entrada del uCP, este arreglo es el común y disponible se le
agrega la resistencias pullup para el anti rebote.
También se tiene el arreglo MCLR, para resetear el uCP
Y por último la entrada por el pin 9 al uC, esta será una entrada de 0 a 5 volts, es la parte final del
arreglo termopar y amplificador, no hay problema en no poner DST puesto que este entrega voltaje.

TABLA I. MEDICIONES REALIZADAS

Valor Valor
1 2 3 4 5
mínimo máximo
Valor observado en
el Sensor
Voltaje a la entrada
del ADC (V)
Valor observado en
la pantalla LCD con
la tecla X en la
simulación
Error absoluto en la
simulación
Valor observado en
la pantalla LCD con
la tecla X en la
implementación
Error absoluto en la
implementación
Rango de medición: Valor medio del error absoluto en la Valor medio del error absoluto en la
simulación: implementación:

CONCLUCIONES

REFERENCIAS
Website
1- https://www.sparkfun.com/datasheets/LCD/ADM1602K-NSW-FBS-3.3v.pdf
2- https://www.sparkfun.com/datasheets/Components/LM7805.pdf
3- https://yoreparo.com/electronica/diseno/preguntas/1218527/lm7805-y-sus-capacitores

Libros y/o PDFs

4- Description general del pic 16f877A
5- Compilador C CCS y simulador Proteus para microcontroladores PIC-> cap 6,7,8

ANEXOS

ANEXO A – DIAGRAMA ESQUEMÁTICO EN LA SIMULACIÓN

 ANEXO B – DIAGRAMA ESQUEMÁTICO COMPLETO DE LA PLACA

ANEXO C – LISTADO DEL PROGRAMA EN C

Programa principal:
1. #include <16F877A.h>

2. #FUSES NOWDT,XT,noprotect,nolvp

3. #device ADC=10

4. #INCLUDE <math.h>

5. #use delay(clock=4000000)

6. #use fast_IO(B)

7. #use fast_IO(D)

8. #define LCD_ENABLE_PIN PIN_B2

9. #define LCD_RS_PIN PIN_B0

10. #define LCD_RW_PIN PIN_B1

11. #define LCD_DATA4 PIN_B4

12. #define LCD_DATA5 PIN_B5

13. #define LCD_DATA6 PIN_B6

14. #define LCD_DATA7 PIN_B7

15. #define use_portd_kbd TRUE

16. #include <lcd.c>

17. #include <kbd4x4.c>

18. char k;

19. char d;

20. int16 X;

21. float TC;

22. float TK;

23. float TF;

24. int cont=0;

25. void disp()

26. {

27. lcd_gotoxy(1,1);

28. lcd_putc("\fMedidor de magnitudes fisicas");

29. }

30.

31. #int_TIMER1

32. void temp1s(void)

33. {

34. if (cont==1)

35. {

36. X = Read_ADC();

37. }

38. set_timer1(21786);

39. cont++;

40. if (cont==2){

41. cont=0;

42. }

43. if(d=='*'){

44. disp();

45. }

46. if(d==50){

47. lcd_putc('\f');
48. TC=247*5.0*X/1024.0;

49. printf(lcd_putc,"\T=%fC",TC);

50. lcd_gotoxy(1,1);

51. }

52. if(d==54){

53. lcd_putc('\f');

54. TK=247*5.0*X/1024.0+273;

55. printf(lcd_putc,"\T=%fK",TK);

56. lcd_gotoxy(1,1);

57. }

58. if(d=='C'){

59. lcd_putc('\f');

60. TF=((9.0*(247*5.0*X/1024.0))/5.0)+32.0;

61. printf(lcd_putc,"\T=%fF",TF);

62. lcd_gotoxy(1,1);

63. }

64. }

65.

66. void main(){

67. setup_timer_1(T1_INTERNAL | T1_DIV_BY_8);

68. set_timer1(21786);

69. enable_interrupts(INT_TIMER1);

70. enable_interrupts(GLOBAL);

71. setup_port_a(ALL_ANALOG);

72. setup_adc(ADC_CLOCK_INTERNAL);

73. set_adc_channel(6);

74. lcd_init();

75. port_b_pullups(TRUE);

76. while(1){

77. k=kbd_getc();

78. if(k!=0 && (k==54 || k==50 || k=='*' || k=='C')){

79. if(k=='*'){

80. disp();
81. d=k;

82. }

83. if(k==50){

84. lcd_putc('\f');

85. TC=247*5.0*X/1024.0;

86. printf(lcd_putc,"\T=%fC",TC);

87. lcd_gotoxy(1,1);

88. d=k;

89. }

90. if(k==54){

91. lcd_putc('\f');

92. TK=247*5.0*X/1024.0+273;

93. printf(lcd_putc,"\T=%fK",TK);

94. lcd_gotoxy(1,1);

95. d=k;

96. }

97. if(k=='C'){

98. lcd_putc('\f');

99. TF=((9.0*(247*5.0*X/1024.0))/5.0)+32;

100. printf(lcd_putc,"\T=%fF",TF);

101. lcd_gotoxy(1,1);

102. d=k;

103. }

104. }

105. }

106. }

Librería modificada <kbd4x4>:

1. ///////////////////////////////////////////////////////////////////////////

2. //// KBD.C ////

3. //// Generic keypad scan driver ////

4. //// ////

5. //// kbd_init() Must be called before any other function. ////

6. //// ////
7. //// c = kbd_getc(c) Will return a key value if pressed or /0 if not ////

8. //// This function should be called frequently so as ////

9. //// not to miss a key press. ////

10. ////
////

11. /////////////////////////////////////////////////////////////////////
//////

12. //// (C) Copyright 1996,2003 Custom Computer Services

////

13. //// This source code may only be used by licensed users of the CCS C
////

14. //// compiler. This source code may only be distributed to other
////

15. //// licensed users of the CCS C compiler. No other

use, reproduction ////

16. //// or distribution is permitted without written permission.

////

17. //// Derivative programs created using this software in object code
////

18. //// form are not restricted in any way.

////

19. /////////////////////////////////////////////////////////////////////
//////

20.

21. ////////////////// The following defines the keypad layout on port D

22.

23. // Un-comment the following define to use port B

24. // #define use_portb_kbd TRUE

25.

26. // Make sure the port used has pull-up resistors (or the LCD) on

27. // the column pins

28.

29. #if defined use_portb_kbd

30. #byte kbd = getenv("SFR:PORTB")

31. #else

32. #byte kbd = getenv("SFR:PORTD")

33. #endif
34.

35. #if defined use_portb_kbd

36. #define set_tris_kbd(x) set_tris_b(x)

37. #else

38. #define set_tris_kbd(x) set_tris_d(x)

39. #endif

40.

41. //Keypad connection: (for example column 0 is B2)

42. // Bx:

43.

44. #ifdef blue_keypad ///////////////////////////////////// For

the blue keypad

45. #define COL0 (1 << 2)

46. #define COL1 (1 << 3)

47. #define COL2 (1 << 6)

48.

49. #define ROW0 (1 << 4)

50. #define ROW1 (1 << 7)

51. #define ROW2 (1 << 1)

52. #define ROW3 (1 << 5)

53.

54. #else ////////////////////////////////////////////////// For

the black keypad

55. #define COL0 (1 << 4)

56. #define COL1 (1 << 5)

57. #define COL2 (1 << 6)

58. #define COL3 (1 << 7)

59.

60. #define ROW0 (1 << 0)

61. #define ROW1 (1 << 1)

62. #define ROW2 (1 << 2)

63. #define ROW3 (1 << 3)

64.

65. #endif
66.

67. #define ALL_ROWS (ROW0|ROW1|ROW2|ROW3)

68. #define ALL_PINS (ALL_ROWS|COL0|COL1|COL2|COL3)

69.

70. // Keypad layout:

71. char const KEYS[4][4] = {{'1','2','3','A'},

72. {'4','5','6','B'},

73. {'7','8','9','C'},

74. {'*','0','#','D'}};

75.

76. #define KBD_DEBOUNCE_FACTOR 33 // Set this number to apx

n/333 where

77. // n is the number of times you

expect

78. // to call kbd_getc each second

79.

80.

81. void kbd_init() {

82. }

83.

84. char kbd_getc( ) {

85. static BYTE kbd_call_count;

86. static int1 kbd_down;

87. static char last_key;

88. static BYTE col;

89.

90. BYTE kchar;

91. BYTE row;

92.

93. kchar='\0';

94. if(++kbd_call_count>KBD_DEBOUNCE_FACTOR) {

95. switch (col) {

96. case 0 : set_tris_kbd(ALL_PINS&~COL0);

97. kbd=~COL0&ALL_PINS;
98. break;

99. case 1 : set_tris_kbd(ALL_PINS&~COL1);

100. kbd=~COL1&ALL_PINS;

101. break;

102. case 2 : set_tris_kbd(ALL_PINS&~COL2);

103. kbd=~COL2&ALL_PINS;

104. break;

105. case 3 : set_tris_kbd(ALL_PINS&~COL3);

106. kbd=~COL3&ALL_PINS;

107. break;

108. }

109.

110. if(kbd_down) {

111. if((kbd & (ALL_ROWS))==(ALL_ROWS)) {

112. kbd_down=FALSE;

113. kchar=last_key;

114. last_key='\0';

115. }

116. } else {

117. if((kbd & (ALL_ROWS))!=(ALL_ROWS)) {

118. if((kbd & ROW0)==0)

119. row=0;

120. else if((kbd & ROW1)==0)

121. row=1;

122. else if((kbd & ROW2)==0)

123. row=2;

124. else if((kbd & ROW3)==0)

125. row=3;

126. last_key =KEYS[row][col];

127. kbd_down = TRUE;

128. } else {

129. ++col;

130. if(col==4)
131. col=0;

132. }

133. }

134. kbd_call_count=0;

135. }

136. set_tris_kbd(ALL_PINS);

137. return(kchar);

138. }
ANEXO D – FOTOGRAFIA DE LA PLACA