Autor Tema: Temperatura y Luminosidad con un LM35a y una LDR (CAD CON INTERRUPCIÓN)  (Leído 7123 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado umalrovi

  • Colaborador
  • PIC16
  • *****
  • Mensajes: 158
    • Aplicaciones Electrónicas
Buenas,

Me he estado pegando varios días para poner en funcionamiento el CAD del pic 16f877A mediante interrupción del CAD.  Ya que tengo un programa un poco complejo y al ver que no me salía nada me puse con el programa que ha hecho RedPic (_ad_temperatura_lm35a_232.c) con una programación bastante estructurada y lo he modificado para que funcione el CAD por interrupción.

Para que nadie pierda el tiempo que estado yo perdiendo por chorradas y gracias a mi colega Azicuetano que me ha ayuda bastante ante la desesperación, publico el código en C. Repito, es una modificación de un programa de redpic.

Si veis que se puede modificar a mejor, os lo agradecería.

Un saludo,

Alf
Aplicaciones Electrónicas
http://www.neoingenia.com/

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5427
    • Picmania by Redraven
Temperatura y Luminosidad con un LM35a y una LDR (CAD CON INTERRUPCIÓN)
« Respuesta #1 en: 31 de Octubre de 2007, 16:24:33 »
Muchas gracias umalrovi por el aporte.

Lo pongo aquí visible:

Código: C++
  1. ////////////////////////////////////////////////////////////////////////////////
  2. //
  3. // Título:     ad_temperatura_lm35a_232_con INT_ADC.c              Versión 1.5
  4. //
  5. // (c)ad_temperatura_lm35a_232_ reformado  31.10.07 by umalrovi
  6. //
  7. // Ubicación: C:\Archivos de programa\PICC\Projects\
  8. //
  9. // Procesador: PIC16F877A con cristal de 20MHz            
  10. //
  11. // Software: CS PCM Version 4.059
  12. //
  13. // Propósito:  
  14. //            
  15. //
  16. // Técnica Empleada:
  17. //
  18. //
  19. //
  20. ////////////////////////////////////////////////////////////////////////////////
  21. #include <16f877A.h>       // Definiciones del PIC 16F877A
  22. #device  adc=10         // Resolución 10 BITS
  23. #device ICD=TRUE        // Habilitamos el modo IDC
  24. #fuses HS,NOWDT,NOPROTECT,NOLVP,PUT,BROWNOUT
  25. #use delay(clock=20000000) // Oscilador a 20 Mhz
  26.  
  27. //##############################################################################
  28. // El compilador realiza las funciones de IO sin programar el registro dirección
  29. // ocupa menos memoria de programa en el PIC.
  30. //##############################################################################
  31.  
  32. #use standard_io(b)
  33.  
  34. #use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7,ERRORS)
  35. // parity=N (no paridad), parity=E(Paridad par), parity=O (paridad impar)
  36. // RS232 Estándar xmit salida de datos, rcv entrada de datos
  37.  
  38.  
  39. ////////////////////////////////////////////////////////////////////////////////
  40. //                            VARIABLES EN RAM                                //
  41. ////////////////////////////////////////////////////////////////////////////////
  42. float  adc_luminosidad=0x00;
  43. float  adc_temperatura=0x00;
  44. float  grados_temperatura=0x00;
  45. int   canal=0;
  46. char Keypress=' ';
  47.  
  48. ////////////////////////////////////////////////////////////////////////////////
  49. //                     DECLARACIÓN DE FUNCIONES                               //
  50. ////////////////////////////////////////////////////////////////////////////////
  51. void toma_adc_y_transmite(void); // pilla el valor de ADC y lo envia por RS232
  52.  
  53. //##############################################################################
  54. //#
  55. //#                  Interrupción recepcición serie USART
  56. //#
  57. //##############################################################################
  58.  
  59. #int_rda
  60. void rda_isr() {
  61.  
  62.    Keypress=0x00;
  63.    if(kbhit()){
  64.       Keypress=getc();
  65.    }
  66. }
  67.  
  68. //##############################################################################
  69. //#
  70. //#              Interrupción encargada del conversor AD
  71. //#
  72. //##############################################################################
  73.  
  74. # INT_AD
  75. void AD_isr()
  76. {
  77.    if (canal==0){
  78.       set_adc_channel(0);
  79.       canal=1;
  80.       delay_ms(1);
  81.       adc_luminosidad=Read_ADC(ADC_READ_ONLY);
  82.       delay_ms(1);
  83.       Read_ADC(ADC_START_ONLY);  //inicia nueva conversion.
  84.    }else{
  85.       set_adc_channel(1);
  86.       canal=0;
  87.       delay_ms(1);
  88.       adc_temperatura=Read_ADC(ADC_READ_ONLY);
  89.       delay_ms(1);
  90.       Read_ADC(ADC_START_ONLY);   //inicia nueva conversion.
  91.    }  
  92. }
  93.  
  94. ////////////////////////////////////////////////////////////////////////////////
  95. //                       DESARROLO DE FUNCIONES                               //
  96. ////////////////////////////////////////////////////////////////////////////////
  97.  
  98. void toma_adc_y_transmite(void){
  99.    disable_interrupts(int_ad);
  100.    grados_temperatura = (int) ((adc_temperatura * 391) / 1000);
  101.  
  102.    printf(" L = %f T = %f (adc= %f)\n",adc_luminosidad,grados_temperatura,adc_temperatura);
  103.  
  104.    enable_interrupts(int_AD);
  105.    Read_ADC(ADC_START_ONLY);
  106. }
  107.  
  108. ////////////////////////////////////////////////////////////////////////////////
  109. //                  PROGRAMA PRINCIPAL VOID MAIN()                            //
  110. ////////////////////////////////////////////////////////////////////////////////
  111.  
  112. void main() {
  113.  
  114.    setup_adc(ADC_CLOCK_DIV_32);
  115.    setup_adc_ports(AN0_AN1_AN3);
  116.    output_low(PIN_B5);
  117.  
  118.    enable_interrupts(int_rda);
  119.    enable_interrupts(int_ad);
  120.    enable_interrupts(global);
  121.  
  122.    canal=0;
  123.    Read_ADC(ADC_START_ONLY);
  124.  
  125.    printf("\n\ AD - LM35a - Monitor\n\n");
  126.  
  127.    do {
  128.  
  129.       if(Keypress!=0x00){
  130.  
  131.          switch(Keypress){
  132.          
  133.             case 't': toma_adc_y_transmite();
  134.                       break;
  135.             case '0': output_low(PIN_B5);
  136.                       printf(" 0 - Calentador OFF\n");
  137.                       break;
  138.             case '1': output_high(PIN_B5);
  139.                       printf(" 1 - Calentador ON\n");
  140.                       break;
  141.          }
  142.  
  143.          Keypress=0x00;
  144.       }
  145.  
  146.  
  147.    } while (TRUE);
  148.  
  149. }
  150.  
  151.  
Contra la estupidez los propios dioses luchan en vano. Schiller
Mi Güeb : Picmania

Desconectado rodrigodedomingo

  • PIC10
  • *
  • Mensajes: 8
Temperatura y Luminosidad con un LM35a y una LDR (CAD CON INTERRUPCIÓN)
« Respuesta #2 en: 04 de Noviembre de 2007, 21:44:09 »

Hola,

tengo un problema,creo que con los tipos de datos q estoy usando.Estoy recibiendo un dato por RS232 y tengo q hacer un cambio de variable antes de sacarlo por el puerto de salida del PIC.El cambio es y=201/93*x-48-32 y redondear el resultado al entero mas proximo pero no me va.
Estoy usando enteros para todo,q pasa cuando multiplicas un entero por un numero decimal y lo vuelcas en un entero otra vez?¿no se redondea el resultado automaticamente?¿como deberia hacer ese cambio de variable?

Muchas gracias,

Saludos.

Desconectado umalrovi

  • Colaborador
  • PIC16
  • *****
  • Mensajes: 158
    • Aplicaciones Electrónicas
Temperatura y Luminosidad con un LM35a y una LDR (CAD CON INTERRUPCIÓN)
« Respuesta #3 en: 13 de Noviembre de 2007, 12:13:25 »
Muy buenas,

Os adjunto una 3ª versión del programa de RedPic (_ad_temperatura_lm35a_232.c). A parte de visualizar la temperatura y la luminosidad comandados por la rs232 programados por interruciones serie y del CAD, esta versión visualiza por un display LCD de 2x16 el valor de la temperatura en ºC, valor del Cad de la temperatura,  de la luminosidad y el estado del calentador. Espero que os sea de ayuda. Os pego el código,
Código: C++
  1. ////////////////////////////////////////////////////////////////////////////////
  2. //
  3. // Titulo:     ad_temperatura_lm35a_232_INT_ADC_Display LCD.c        Versión 2.0
  4. //
  5. // (c)ad_temperatura_lm35a_232_ reformado  13.11.07 by umalrovi
  6. //
  7. // Ubicación: C:\Archivos de programa\PICC\Projects\
  8. //
  9. // Procesador: PIC16F877A con cristal de 20MHz            
  10. //
  11. // Software: CS PCM Version 4.059
  12. //
  13. // Propósito:  
  14. //            
  15. //
  16. // Técnica Empleada:
  17. //
  18. //
  19. //
  20. ////////////////////////////////////////////////////////////////////////////////
  21. #include <16f877A.h>       // Definiciones del PIC 16F877A
  22. #device  adc=10         // Resolución 10 BITS
  23. #device ICD=TRUE        // Habilitamos el modo IDC
  24. #fuses HS,NOWDT,NOPROTECT,NOLVP,PUT,BROWNOUT
  25. #use delay(clock=20000000) // Oscilador a 20 Mhz
  26.  
  27. //##############################################################################
  28. // El compilador realiza las funciones de IO sin programar el registro dirección
  29. // ocupa menos memoria de programa en el PIC.
  30. //##############################################################################
  31.  
  32. #use standard_io(b)
  33.  
  34. #use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7,ERRORS)
  35. // parity=N (no paridad), parity=E(Paridad par), parity=O (paridad impar)
  36. // RS232 Estándar xmit salida de datos, rcv entrada de datos
  37.  
  38.  
  39. ////////////////////////////////////////////////////////////////////////////////
  40. //                             DEFINE                                         //
  41. ////////////////////////////////////////////////////////////////////////////////
  42. //#define BI input(PIN_B0)
  43.  
  44. #define LCD_DB4 PIN_D4
  45. #define LCD_DB5 PIN_D5
  46. #define LCD_DB6 PIN_D6
  47. #define LCD_DB7 PIN_D7
  48.  
  49. // si solo va a utilizar escritura en el LCD conecta R/W a GND y
  50. // comente la siguiente línea
  51.  
  52. #define USE_LCD_RW 1
  53.  
  54. // definir a continuación qué pines del PIC manejan las señales de control
  55.  
  56. #define LCD_RS PIN_D1
  57. #define LCD_RW PIN_D2
  58. #define LCD_E PIN_D0
  59.  
  60. #include "flex_lcd_2.c"      //libreria manejo lcd editada por REDPIC
  61.  
  62. ////////////////////////////////////////////////////////////////////////////////
  63. //                            VARIABLES EN RAM                                //
  64. ////////////////////////////////////////////////////////////////////////////////
  65. float  adc_luminosidad=0x00;
  66. float  adc_temperatura=0x00;
  67. float  grados_temperatura=0;
  68. int   canal=0;
  69. int   calentador=0;
  70. char Keypress=' ';
  71.  
  72. ////////////////////////////////////////////////////////////////////////////////
  73. //                     DECLARACIÓN DE FUNCIONES                               //
  74. ////////////////////////////////////////////////////////////////////////////////
  75.  
  76. void toma_adc_y_transmite(void); // pilla el valor de ADC y lo envia por RS232
  77. void visualiza_parametros_LCD(void); //muestra los valores de temp. y luminosidad
  78.  
  79.  
  80. //##############################################################################
  81. //#
  82. //#                  Interrupción recepcición serie USART
  83. //#
  84. //##############################################################################
  85.  
  86. #int_rda
  87. void rda_isr() {
  88.  
  89.    Keypress=0x00;
  90.    if(kbhit()){
  91.       Keypress=getc();
  92.    }
  93. }
  94.  
  95. //##############################################################################
  96. //#
  97. //#              Interrupción encargada del conversor AD
  98. //#
  99. //##############################################################################
  100.  
  101. # INT_AD
  102. void AD_isr()
  103. {
  104.    if (canal==0){
  105.       set_adc_channel(0);
  106.       canal=1;
  107.       delay_ms(1);
  108.       adc_luminosidad=Read_ADC(ADC_READ_ONLY);
  109.       delay_ms(1);
  110.       Read_ADC(ADC_START_ONLY);  //inicia nueva conversion.
  111.    }else{
  112.       set_adc_channel(1);
  113.       canal=0;
  114.       delay_ms(1);
  115.       adc_temperatura=Read_ADC(ADC_READ_ONLY);
  116.       delay_ms(1);
  117.       Read_ADC(ADC_START_ONLY);   //inicia nueva conversion.
  118.    }  
  119. }
  120.  
  121. ////////////////////////////////////////////////////////////////////////////////
  122. //                       DESARROLO DE FUNCIONES                               //
  123. ////////////////////////////////////////////////////////////////////////////////
  124.  
  125. void toma_adc_y_transmite(void){
  126.    disable_interrupts(int_ad);
  127.    
  128.    grados_temperatura = (int) ((adc_temperatura * 391) / 1000);
  129.  
  130.    printf(" L = %.0f T = %.0f (adc= %.0f)\n",adc_luminosidad,grados_temperatura,adc_temperatura);
  131.  
  132.    enable_interrupts(int_AD);  // Habilita las interrupciones globales
  133.    
  134. // Inicializa el CAD y cuando termine salta a vector interrupción
  135.    
  136.    Read_ADC(ADC_START_ONLY);
  137.    
  138.  
  139. }
  140.  
  141. void visualiza_parametros_LCD(void){
  142.  
  143. // Desabilitamos la int del CAD para pillar el valor y guardarlo en su variable
  144. // y posteriormente hacer calculos.
  145.   disable_interrupts(int_ad);
  146.  
  147.   grados_temperatura =(float)((adc_temperatura * 391) / 1000);
  148.  
  149.   lcd_gotoxy(1,1);
  150.   printf(lcd_putc,"T=%.0f  (AD=%.0f)      "grados_temperatura,adc_temperatura);
  151.   lcd_gotoxy(7,2);
  152.   printf(lcd_putc,"Ladc=%.0f    "adc_luminosidad);
  153.   if (calentador==0){
  154.       lcd_gotoxy(1,2);
  155.       printf(lcd_putc,"C=OFF ");
  156.   }else{
  157.       lcd_gotoxy(1,2);
  158.       printf(lcd_putc,"C=ON ");
  159.   }
  160. // Volvemos a Habilitar las interrupciones del CAD
  161.   enable_interrupts(int_ad);
  162. }
  163.  
  164. ////////////////////////////////////////////////////////////////////////////////
  165. //                  PROGRAMA PRINCIPAL VOID MAIN()                            //
  166. ////////////////////////////////////////////////////////////////////////////////
  167.  
  168. void main() {
  169.  
  170.    setup_adc(ADC_CLOCK_DIV_32);
  171.    setup_adc_ports(AN0_AN1_AN3);
  172.    output_low(PIN_B5);
  173.  
  174.    enable_interrupts(int_rda);
  175.    enable_interrupts(int_ad);
  176.    enable_interrupts(global);
  177.  
  178.    canal=0;
  179.    Read_ADC(ADC_START_ONLY); // Inicia el CAD por int.
  180.  
  181.    printf("\n\ AD - LM35a - Monitor\n\n"); // muestra por la RS232
  182.    
  183.    lcd_init();
  184.    lcd_setcursor(0,0);
  185.    lcd_gotoxy(1,1);
  186.    printf(lcd_putc,"\fCAD Temp. LM35a \n  foro todopic"); //muestra por la LCD
  187.    delay_ms(7000);
  188.    printf(lcd_putc,"\fV2.0 umalrovi \n  foro todopic"); //muestra por la LCD
  189.    delay_ms(7000);
  190.    do {
  191.      
  192.       visualiza_parametros_LCD();
  193.       if(Keypress!=0x00){
  194.  
  195.          switch(Keypress){
  196.          
  197.             case 't': toma_adc_y_transmite();
  198.                       break;
  199.             case '0': output_low(PIN_B5);
  200.                       printf(" 0 - Calentador OFF\n");
  201.                       calentador=0;
  202.                       break;
  203.             case '1': output_high(PIN_B5);
  204.                       printf(" 1 - Calentador ON\n");
  205.                       calentador=1;
  206.                       break;
  207.          }
  208.          Keypress=0x00;
  209.       }
  210.    } while (TRUE);
  211.  
  212. }
  213.  

P.D. El único problema que tengo es que quiero representar el caracter "º" para poner en el display 40ºC y no me sale correctamente a ver si alguno de vosotros sabe como representarlo. Me he leido docuemntación del foro pero no he sacado nada en claro.

Saludos Alfunsetttt
Aplicaciones Electrónicas
http://www.neoingenia.com/

Desconectado BrunoF

  • Administrador
  • DsPIC30
  • *******
  • Mensajes: 3865
Temperatura y Luminosidad con un LM35a y una LDR (CAD CON INTERRUPCIÓN)
« Respuesta #4 en: 13 de Noviembre de 2007, 18:58:33 »
Buscá en la tabla de caracteres del HT47780(http://www.sparkfun.com/datasheets/LCD/HD44780.pdf) el valor binario del símbolo en cuestión. Después podés enviar dicho caracter a la función lcd_putc().

Por lo que veo es el 0b10110000, o lo que es lo mismo: 176 en sistema decimal.

Saludos!
"All of the books in the world contain no more information than is broadcast as video in a single large American city in a single year. Not all bits have equal value."  -- Carl Sagan

Sólo responderé a mensajes personales, por asuntos personales. El resto de las consultas DEBEN ser escritas en el foro público. Gracias.

Desconectado pocher

  • Moderador Local
  • DsPIC30
  • *****
  • Mensajes: 2567
Temperatura y Luminosidad con un LM35a y una LDR (CAD CON INTERRUPCIÓN)
« Respuesta #5 en: 14 de Noviembre de 2007, 02:18:08 »
Código: [Seleccionar]
#include <16f876.h>
#use delay(clock=4000000)

#fuses XT, NOPROTECT, NOPUT, NOWDT, NOBROWNOUT, NOLVP, NOCPD

#include <lcd.c>

void main(void)
{
lcd_init();

//simbolito de grados centigrados

lcd_send_byte(0,0x40); // escribimos en la cgram (0), en la direccion 64=0x40
 
lcd_send_byte(1,0x00); // | | | | | |      0x00=0   La altura del caracter es de 7 bytes
lcd_send_byte(1,0x0C); // | |x|x| | |       0x0C=12
lcd_send_byte(1,0x12); // |x| | |x| |       0x12=18
lcd_send_byte(1,0x12); // |x| | |x| |      0x12=18
lcd_send_byte(1,0x0C); // | |x|x| | |       0x0C=12
lcd_send_byte(1,0x00); // | | | | | |      0x00=0 
lcd_send_byte(1,0x00); // | | | | | |      0x00=0 
lcd_send_byte(1,0x00); // | | | | | |      0x00=0   ¡sobra!

//una ñ un poco cutre, seguro que se puede mejorar

lcd_send_byte(0,0x48);  // escribimos en la cgram (1), en la direccion 64+8=72=0x48

lcd_send_byte(1,0x09);  // | |x| | |x|      0x09=9  La altura del caracter es de 7 bytes
lcd_send_byte(1,0x16);  // |x| |x|x| |      0x16=22
lcd_send_byte(1,0x00);  // | | | | | |      0x00=0   
lcd_send_byte(1,0x16);  // |x| |x|x| |      0x16=22   
lcd_send_byte(1,0x19);  // |x|x| | |x|      0x19=25   
lcd_send_byte(1,0x11);  // |x| | | |x|      0x11=17   
lcd_send_byte(1,0x11);  // |x| | | |x|      0x11=17   
lcd_send_byte(1,0x00);  // | | | | | |      0x00=0   ¡sobra!

lcd_send_byte(0,0x50);  // escribimos en la cgram (2), en la dirección 72+8=80=0x50

//lcd_send_byte(1,0x00);  // | | | | | |      0x00=0
lcd_send_byte(1,0x1f);  // |x|x|x|x|x| 
lcd_send_byte(1,0x00);  // | | | | | |      0x00=0   
lcd_send_byte(1,0x1f);  // |x|x|x|x|x| 
lcd_send_byte(1,0x00);  // | | | | | |      0x00=0   
lcd_send_byte(1,0x1f);  // |x|x|x|x|x| 
lcd_send_byte(1,0x00);  // | | | | | |      0x00=0   
lcd_send_byte(1,0x11);  // |x| | | |x|

lcd_send_byte(0,0x58);  // escribimos en la cgram (3), en la dirección 80+8=88=0x58

lcd_send_byte(1,0x1f);  // |x|x|x|x|x| 
lcd_send_byte(1,0x1f);  // |x|x|x|x|x| 
lcd_send_byte(1,0x1f);  // |x|x|x|x|x| 
lcd_send_byte(1,0x1f);  // |x|x|x|x|x| 
lcd_send_byte(1,0x1f);  // |x|x|x|x|x| 
lcd_send_byte(1,0x00);  // | | | | | |      0x00=0   
lcd_send_byte(1,0x1f);  // |x|x|x|x|x|

lcd_send_byte(0,0x60);  // escribimos en la cgram (4), en la dirección 88+8=96=0x60

lcd_send_byte(1,0x1f);  // |x|x|x|x|x| 
lcd_send_byte(1,0x1f);  // |x|x|x|x|x| 
lcd_send_byte(1,0x00);  // | | | | | | 
lcd_send_byte(1,0x00);  // | | | | | | 
lcd_send_byte(1,0x00);  // | | | | | | 
lcd_send_byte(1,0x1f);  // |x|x|x|x|x|     
lcd_send_byte(1,0x1f);  // |x|x|x|x|x|

lcd_send_byte(0,0x68);  // escribimos en la cgram (5), en la dirección 96+8=104=0x68

lcd_send_byte(1,0x11);  // |x| | | |x|
lcd_send_byte(1,0x11);  // |x| | | |x| 
lcd_send_byte(1,0x11);  // |x| | | |x| 
lcd_send_byte(1,0x11);  // |x| | | |x| 
lcd_send_byte(1,0x11);  // |x| | | |x| 
lcd_send_byte(1,0x11);  // |x| | | |x| 
lcd_send_byte(1,0x11);  // |x| | | |x|   

lcd_send_byte(0,0x70); // escribimos en la cgram (0), en la direccion 104+8=112=0x70
 
lcd_send_byte(1,0x00); // | | | | | |      0x00=0   La altura del caracter es de 7 bytes
lcd_send_byte(1,0x0C); // | |x|x| | |       0x0C=12
lcd_send_byte(1,0x12); // |x| | |x| |       0x12=18
lcd_send_byte(1,0x12); // |x| | |x| |      0x12=18
lcd_send_byte(1,0x0C); // | |x|x| | |       0x0C=12
lcd_send_byte(1,0x00); // | | | | | |      0x00=0 
lcd_send_byte(1,0x00); // | | | | | |      0x00=0 
lcd_send_byte(1,0x00); // | | | | | |      0x00=0   ¡sobra!

//una ñ un poco cutre, seguro que se puede mejorar

lcd_send_byte(0,0x78);  // escribimos en la cgram (1), en la direccion 112+8=120=0x78

lcd_send_byte(1,0x09);  // | |x| | |x|      0x09=9  La altura del caracter es de 7 bytes
lcd_send_byte(1,0x16);  // |x| |x|x| |      0x16=22
lcd_send_byte(1,0x00);  // | | | | | |      0x00=0   
lcd_send_byte(1,0x16);  // |x| |x|x| |      0x16=22   
lcd_send_byte(1,0x19);  // |x|x| | |x|      0x19=25   
lcd_send_byte(1,0x11);  // |x| | | |x|      0x11=17   
lcd_send_byte(1,0x11);  // |x| | | |x|      0x11=17   
lcd_send_byte(1,0x00);  // | | | | | |      0x00=0   ¡sobra!
/*
lcd_send_byte(0,0x80);  // escribimos en la cgram (1), en la direccion 120+8=128=0x80

lcd_send_byte(1,0x09);  // | |x| | |x|      0x09=9  La altura del caracter es de 7 bytes
lcd_send_byte(1,0x16);  // |x| |x|x| |      0x16=22
lcd_send_byte(1,0x00);  // | | | | | |      0x00=0   
lcd_send_byte(1,0x16);  // |x| |x|x| |      0x16=22   
lcd_send_byte(1,0x19);  // |x|x| | |x|      0x19=25   
lcd_send_byte(1,0x11);  // |x| | | |x|      0x11=17   
lcd_send_byte(1,0x11);  // |x| | | |x|      0x11=17   
lcd_send_byte(1,0x00);  // | | | | | |      0x00=0   ¡sobra!
*/   
lcd_gotoxy(1,1);
lcd_send_byte(1,0);    //Llamada a escritura del caracter "º", CGRAM1

lcd_gotoxy(5,1);
lcd_send_byte(1,1);    //Llamada a escritura del caracter "4 rayas"

lcd_gotoxy(10,1);
lcd_send_byte(1,2);    //Llamada a escritura del caracter "_"

lcd_gotoxy(15,1);
lcd_send_byte(1,3);    //Llamada a escritura del caracter "3 rayas y 2 puntos"

lcd_gotoxy(1,2);
lcd_send_byte(1,4);    //Llamada a escritura del caracter ""

lcd_gotoxy(5,2);
lcd_send_byte(1,5);    //Llamada a escritura del caracter ""

lcd_gotoxy(10,2);
lcd_send_byte(1,6);    //Llamada a escritura del caracter ""

lcd_gotoxy(15,2);
lcd_send_byte(1,7);    //Llamada a escritura del caracter ""

lcd_gotoxy(16,2);
lcd_send_byte(1,8);    //Llamada a escritura del caracter "_"   
 
}





Un saludo

« Última modificación: 14 de Noviembre de 2007, 02:39:10 por pocher »

Desconectado umalrovi

  • Colaborador
  • PIC16
  • *****
  • Mensajes: 158
    • Aplicaciones Electrónicas
Temperatura y Luminosidad con un LM35a y una LDR (CAD CON INTERRUPCIÓN)
« Respuesta #6 en: 14 de Noviembre de 2007, 06:06:40 »
Muchas gracias Pocher y bruno por vuestras respuestas!!!

Necesito introducirlo en la siguiente parte del código, exactamente printf(lcd_putc,"T=%.0f (AD=%.0f)      "grados_temperatura,adc_temperatura);

¿Donde pongo esactamente el código? El problema que veo es que cuando la temperatura es T=0 estará en la 4ª posición el símbolo de grados centígrados, pero cuando la temperatura T=10ºC el símbolo estará en la 5ª posición y si la temperatura es T=100ºC pues el simbolito estará en la 6ª posición.

Un saludo.

Código: C++
  1. void visualiza_parametros_LCD(void){
  2.  
  3. // Desabilitamos la int del CAD para pillar el valor y guardarlo en su variable
  4. // y posteriormente hacer calculos.
  5.   disable_interrupts(int_ad);
  6.  
  7.   grados_temperatura =(float)((adc_temperatura * 391) / 1000);
  8.  
  9.   lcd_gotoxy(1,1);
  10.   printf(lcd_putc,"T=%.0f (AD=%.0f)      "grados_temperatura,adc_temperatura);
  11.   lcd_gotoxy(7,2);
  12.   printf(lcd_putc,"Ladc=%.0f    "adc_luminosidad);
  13.   if (calentador==0){
  14.       lcd_gotoxy(1,2);
  15.       printf(lcd_putc,"C=OFF ");
  16.   }else{
  17.       lcd_gotoxy(1,2);
  18.       printf(lcd_putc,"C=ON ");
  19.   }
  20. // Volvemos a Habilitar las interrupciones del CAD
  21.   enable_interrupts(int_ad);
  22. }
  23.  
  24.  
Aplicaciones Electrónicas
http://www.neoingenia.com/

Desconectado BrunoF

  • Administrador
  • DsPIC30
  • *******
  • Mensajes: 3865
Temperatura y Luminosidad con un LM35a y una LDR (CAD CON INTERRUPCIÓN)
« Respuesta #7 en: 14 de Noviembre de 2007, 16:00:00 »
Código: C++
  1. #define    grad     176
  2.  
  3. void visualiza_parametros_LCD(void){
  4. char grad;
  5. // Desabilitamos la int del CAD para pillar el valor y guardarlo en su variable
  6. // y posteriormente hacer calculos.
  7.   disable_interrupts(int_ad);
  8.  
  9.   grados_temperatura =(float)((adc_temperatura * 391) / 1000);
  10.  
  11.   lcd_gotoxy(1,1);
  12.   printf(lcd_putc,"T=%.0f%c (AD=%.0f)      "grados_temperatura,grad,adc_temperatura);
  13.   lcd_gotoxy(7,2);
  14.   printf(lcd_putc,"Ladc=%.0f    "adc_luminosidad);
  15.   if (calentador==0){
  16.       lcd_gotoxy(1,2);
  17.       printf(lcd_putc,"C=OFF ");
  18.   }else{
  19.       lcd_gotoxy(1,2);
  20.       printf(lcd_putc,"C=ON ");
  21.   }
  22. // Volvemos a Habilitar las interrupciones del CAD
  23.   enable_interrupts(int_ad);
  24. }
  25.  
  26.  

En el ISIS no muestra el simbolo, pero antes de recurrir a la CGRAM(lo que te propone Potcher) probá en el LCD de verdad. Por ahí el LCD del ISIS posee otra tabla de caracteres.

Saludos.
"All of the books in the world contain no more information than is broadcast as video in a single large American city in a single year. Not all bits have equal value."  -- Carl Sagan

Sólo responderé a mensajes personales, por asuntos personales. El resto de las consultas DEBEN ser escritas en el foro público. Gracias.

Desconectado piclord

  • PIC12
  • **
  • Mensajes: 52
Temperatura y Luminosidad con un LM35a y una LDR (CAD CON INTERRUPCIÓN)
« Respuesta #8 en: 14 de Noviembre de 2007, 23:58:54 »
Hola

Para los grados, prueba a usar alguno de los siguientes ejemplos:

1.- printf(lcd_putc,"Temperatura=%2d ßC", temperatura);  //  ß=alt+225=0xDF
2.- printf(lcd_putc,"Temperatura=%2d %c C",temperatura, 0xdf);
3.- printf(lcd_putc,"Temperatura=" "%2d " "\xdf" "C", temperatura);
4.- lcd_send_byte(1,0xDF);  // imprime el simbolo " ° " usando la tabla de caracteres del LCD
                                         //esto sirve para toda la gama de caracteres del LCD

Generalmente uso la primera... El formato de salida %2d lo puse como ejemplo, puedes usar float si quieres, en fin...

Bye
« Última modificación: 17 de Noviembre de 2007, 21:58:46 por piclord »

Desconectado BrunoF

  • Administrador
  • DsPIC30
  • *******
  • Mensajes: 3865
Temperatura y Luminosidad con un LM35a y una LDR (CAD CON INTERRUPCIÓN)
« Respuesta #9 en: 15 de Noviembre de 2007, 05:46:47 »
Ahí te postearon la solución más simple. Yo no pude porque hay que ponerse a probar como loco hasta dar con el caracter equivalente para el CCS. Esto sucede por discrepancias entre los programas y sus tablas de caracteres...

Saludos!.
"All of the books in the world contain no more information than is broadcast as video in a single large American city in a single year. Not all bits have equal value."  -- Carl Sagan

Sólo responderé a mensajes personales, por asuntos personales. El resto de las consultas DEBEN ser escritas en el foro público. Gracias.

Desconectado umalrovi

  • Colaborador
  • PIC16
  • *****
  • Mensajes: 158
    • Aplicaciones Electrónicas
Temperatura y Luminosidad con un LM35a y una LDR (CAD CON INTERRUPCIÓN)
« Respuesta #10 en: 15 de Noviembre de 2007, 06:00:29 »
Muchas gracias BrunoF, Piclord y Bruno.

He probado todas las soluciones y solo me ha funcionado lo del piclord.  Pero yo me pregunto ¿cómo saca el símbolo de º poniendo en el printf  alt+255(ß)?.

Sin embargo lo que dice BrunoF  lo veo mucho más lógico ya que viendo el datasheet el simbolo º tiene el valor 176 en decimal.  Lo de BrunoF no me sale porque estaba mirando un datasheet de otro LCD.

Mcuhas gracias!!
« Última modificación: 15 de Noviembre de 2007, 06:17:11 por umalrovi »
Aplicaciones Electrónicas
http://www.neoingenia.com/

Desconectado umalrovi

  • Colaborador
  • PIC16
  • *****
  • Mensajes: 158
    • Aplicaciones Electrónicas
Temperatura y Luminosidad con un LM35a y una LDR (CAD CON INTERRUPCIÓN)
« Respuesta #11 en: 15 de Noviembre de 2007, 06:30:27 »
Bueno respondo a mis propias preguntas. Interneteando por la red he querido mirar si el caracter ASCII(B) correspondía con el número 11011111b y a su vez corresponde con el 0xDF. Por eso a la hora de escribir el caracter betta funciona a la perfección ya que mi tipo LCD a la hora de pasar ese valor corresponde con el símbolo del grado centígrado.

¿Porqué lo de Brunof no me funciona? porque tengo otro tipo de LCD de 2x16 y para poner el símbolo del grado centígrado hay que hacer lo mismo pero en vez de valer grad 176 vale 223.

Todo es por no mirar bien los datasheets!!! Ha sido un despiste.

Saludos Alf
Aplicaciones Electrónicas
http://www.neoingenia.com/

Desconectado umalrovi

  • Colaborador
  • PIC16
  • *****
  • Mensajes: 158
    • Aplicaciones Electrónicas
Temperatura y Luminosidad con un LM35a y una LDR (CAD CON INTERRUPCIÓN)
« Respuesta #12 en: 19 de Noviembre de 2007, 13:42:27 »
Buenas compañeros,

aquí os adjunto una 4ª versión del programa de RedPic (_ad_temperatura_lm35a_232.c).
Técnica Empleada:

//    * CAD por interrupción.
//    * Interrupción serie.
//    * Display LCD utilizando librería flex_lcd_2.
//    * Comandos RS232 CON Buffer
//    * Guarda el estado del calentador en EEPROM

Todo gracias a redpic, nocturno, maumix, MGLsoft y todos los que participan en este foro!!! Casi todo el código es de REDPIC e integrado en uno solo por mi. Si veis alguno de vosotros que se puede simplificar mejor os agradecería que lo comentáseis.

Código: C++
  1. ////////////////////////////////////////////////////////////////////////////////
  2. //
  3. // Título:  ad_temperatura_lm35a_232_INT_ADC_Display LCD_CON Buffer_Versión 3.0
  4. //
  5. // (c)ad_temperatura_lm35a_232_ reformado  19.11.07 by umalrovi
  6. //
  7. // Ubicación: C:\Archivos de programa\PICC\Projects\
  8. //
  9. // Procesador: PIC16F877A con cristal de 20MHz            
  10. //
  11. // Software: CS PCM Version 4.059
  12. //
  13. // Propósito:  Se quiere visualizar el valor de un sensor de temperatura y de
  14. //          luminosidad en modo local por medio de un display LCD y en modo
  15. //          remoto por un PC, mediante el puerto de comunicaciones rs232.
  16. //
  17. // El PC enviará uno de los siguientes comandos descritos mas abajo y el PIC
  18. // hará la acción oportuna.            
  19. //
  20. // Técnica Empleada:
  21. //
  22. //    * CAD por interrupción.
  23. //    * Interrupción serie.
  24. //    * Display LCD utilizando librería flex_lcd_2.
  25. //    * Comandos RS232 con Buffer
  26. //    * Guarda el estado del calentador en EEPROM
  27. //
  28. //  COMANDOS rs232 (RC= retorno de carro):
  29. //
  30. //    "C1_ON+RC"   ----------  Pone el calentador en marcha
  31. //    "C1_OFF+RC"  ----------  Apaga el calentador
  32. //    "STDO+RC"    ----------  Mira el estado del calentador (On/Off)
  33. //    "V_CAD+RC"   ----------  Valor del CAD
  34. //    "BORRAR_E+RC"----------  Borra las variables guardadas en eeprom
  35. //    "VERSION+RC" ---------- Muestra la versión del programa
  36. //    "RESET+RC"   ---------- Resetea el micro por watchdog
  37. //
  38. //
  39. ////////////////////////////////////////////////////////////////////////////////
  40. #include <16f877A.h>       // Definiciones del PIC 16F877A
  41. #device  adc=10         // Resolución 10 BITS
  42. #device ICD=TRUE        // Habilitamos el modo IDC
  43. #fuses HS,NOWDT,NOPROTECT,NOLVP,PUT,BROWNOUT
  44. #use delay(clock=20000000) // Oscilador a 20 Mhz
  45.  
  46. //##############################################################################
  47. // El compilador realiza las funciones de IO sin programar el registro dirección
  48. // ocupa menos memoria de programa en el PIC.
  49. //##############################################################################
  50.  
  51. #use standard_io(a)
  52. #use standard_io(b)
  53. #use standard_io(c)
  54. #use standard_io(d)
  55. #use standard_io(e)
  56.  
  57. #use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7,ERRORS)
  58. // parity=N (no paridad), parity=E(Paridad par), parity=O (paridad impar)
  59. // RS232 Estándar xmit salida de datos, rcv entrada de datos
  60.  
  61.  
  62. ////////////////////////////////////////////////////////////////////////////////
  63. //                             DEFINE                                         //
  64. ////////////////////////////////////////////////////////////////////////////////
  65.  
  66.  
  67. #define LCD_DB4 PIN_D4
  68. #define LCD_DB5 PIN_D5
  69. #define LCD_DB6 PIN_D6
  70. #define LCD_DB7 PIN_D7
  71.  
  72. // si solo va a utilizar escritura en el LCD conecta R/W a GND y
  73. // comente la siguiente línea
  74.  
  75. #define USE_LCD_RW 1
  76.  
  77. // definir a continuación qué pines del PIC manejan las señales de control
  78.  
  79. #define LCD_RS PIN_D1
  80. #define LCD_RW PIN_D2
  81. #define LCD_E PIN_D0
  82.  
  83. #include "flex_lcd_2.c"      //libreria manejo lcd editada por REDPIC
  84.  
  85.  
  86. #define  calentador_OFF   output_low(PIN_B1)
  87. #define  calentador_ON    output_high(PIN_B1)
  88.  
  89.  
  90. ////////////////////////////////////////////////////////////////////////////////
  91. //                            CONSTANTES                                      //
  92. ////////////////////////////////////////////////////////////////////////////////
  93.  
  94. int const lenbuff=32;      // Longitud de buffer, Ajustar  a lo que desees
  95.                           //  o te sea posible)
  96.  
  97. ////////////////////////////////////////////////////////////////////////////////
  98. //                            VARIABLES EN RAM                                //
  99. ////////////////////////////////////////////////////////////////////////////////
  100. float  adc_luminosidad=0x00;
  101. float  adc_temperatura=0x00;
  102. float  grados_temperatura=0;
  103. int   canal=0;
  104. char grad=0b11011111;                      // simblo "º" según datasheet
  105.  
  106. int  xbuff=0x00;                         // Índice: siguiente char en cbuff
  107. char cbuff[lenbuff];                    // Buffer
  108. char rcvchar=0x00;                     // último caracter recibido
  109. int1 flagcommand=0;                   // Flag para indicar comando disponible
  110. int1 estado_calentador=0;            // Estado del Calentador
  111. int1 flag_reset=0;                  // Indica un reset por consola(PC)
  112.  
  113.  
  114. ////////////////////////////////////////////////////////////////////////////////
  115. //                     DECLARACIÓN DE FUNCIONES                               //
  116. ////////////////////////////////////////////////////////////////////////////////
  117.  
  118. void toma_adc_y_transmite(void); // pilla el valor de ADC y lo envia por RS232
  119. void visualiza_parametros_LCD(void);//muestra los valores de temp. y luminosidad
  120. void inicbuff(void);                    // Borra buffer
  121. int  addcbuff(char c);                 // añade caracter recibido al buffer
  122. void procesa_comando(void);           // Procesa comando
  123.  
  124.  
  125. //##############################################################################
  126. //#
  127. //#                  Interrupción recepcición serie USART
  128. //#
  129. //##############################################################################
  130.  
  131. #int_rda
  132. void serial_isr() {                    // Interrupción recepción serie USART
  133.  
  134.    rcvchar=0x00;                       // Inicializo caracter recibido
  135.    if(kbhit()){                        // Si hay algo pendiente de recibir ...
  136.       rcvchar=getc();                  // lo descargo y ...
  137.       addcbuff(rcvchar);               // lo añado al buffer y ...
  138.    }
  139. }
  140.  
  141. //##############################################################################
  142. //#
  143. //#              Interrupción encargada del conversor AD
  144. //#
  145. //##############################################################################
  146.  
  147. # INT_AD
  148. void AD_isr()
  149. {
  150.    if (canal==0){
  151.       set_adc_channel(0);
  152.       canal=1;
  153.       delay_ms(1);
  154.       adc_luminosidad=Read_ADC(ADC_READ_ONLY);
  155.       delay_ms(1);
  156.       Read_ADC(ADC_START_ONLY);  //inicia nueva conversion.
  157.    }else{
  158.       set_adc_channel(1);
  159.       canal=0;
  160.       delay_ms(1);
  161.       adc_temperatura=Read_ADC(ADC_READ_ONLY);
  162.       delay_ms(1);
  163.       Read_ADC(ADC_START_ONLY);   //inicia nueva conversion.
  164.    }  
  165. }
  166.  
  167. ////////////////////////////////////////////////////////////////////////////////
  168. //                       DESARROLO DE FUNCIONES                               //
  169. ////////////////////////////////////////////////////////////////////////////////
  170.  
  171. void toma_adc_y_transmite(void){
  172.    
  173.    disable_interrupts(int_ad);
  174.    
  175.    grados_temperatura = (float) ((adc_temperatura * 391) / 1000);
  176.  
  177.    printf(" L = %.0f T = %.2f (adc= %.0f)\n",adc_luminosidad,grados_temperatura,adc_temperatura);
  178.  
  179.    enable_interrupts(int_AD);  // Habilita las interrupciones globales
  180.    
  181. // Inicializa el CAD y cuando termine salta a vector interrupción
  182.    
  183.    Read_ADC(ADC_START_ONLY);
  184.    
  185.  
  186. }
  187.  
  188. void visualiza_parametros_LCD(void){
  189.    
  190. // Desabilitamos la int del CAD para pillar el valor y guardarlo en su variable
  191. // y posteriormente hacer calculos.
  192.  
  193.   disable_interrupts(int_ad);
  194.  
  195.   grados_temperatura =(float)((adc_temperatura * 391) / 1000);
  196.  
  197.   lcd_gotoxy(1,1);
  198.   printf(lcd_putc,"T=%.1f%cC ad=%.0f      "grados_temperatura,grad,adc_temperatura);
  199. // para expresar en el LCD el simbolo de grados hay que poner ß (alt+225) que
  200. //corresponden al caracter decimal 223
  201.   lcd_gotoxy(7,2);
  202.   printf(lcd_putc,"Ladc=%.0f    "adc_luminosidad);
  203.   if (estado_calentador==0){
  204.       lcd_gotoxy(1,2);
  205.       printf(lcd_putc,"C=OFF ");
  206.   }else{
  207.       lcd_gotoxy(1,2);
  208.       printf(lcd_putc,"C=ON ");
  209.   }
  210. // Volvemos a Habilitar las interrupciones del CAD
  211.   enable_interrupts(int_ad);
  212. }
  213.  
  214.  
  215. void inicbuff(void){                   // Inicia a \0 cbuff -------------------
  216.    int i=0;
  217.  
  218.    for(i=0;i<lenbuff;i++){             // Bucle que pone a 0 todos los
  219.       cbuff[i]=0x00;                   // caracteres en el buffer
  220.    }
  221.    xbuff=0x00;                         // Inicializo el indice de siguiente
  222.                                        // caracter
  223. }
  224.  
  225. int addcbuff(char c){                  // Añade a cbuff -----------------------
  226.  
  227.       switch(c){
  228.          case 0x0D:                    // Enter -> Habilita Flag para procesar
  229.             flagcommand=1;             // Comando en Main
  230.             break;
  231.          case 0x08:                 // Del   -> Borra último caracter del Buffer
  232.             if(xbuff>0) cbuff[--xbuff]=0x00;
  233.             break;
  234.          case 0x01B:                   // Esc   -> Borra el Buffer completamente
  235.             inicbuff();
  236.             break;
  237.          default:
  238.             cbuff[xbuff++]=c;          // Añade caracter recibido al Buffer
  239.       }
  240. }
  241.  
  242. void procesa_comando(void){
  243.  
  244.    int i=0;
  245.    int1 flag=0;                        // Indica si el comando es valido
  246.    char arg[lenbuff];                   // Argumento de comando (si lo tiene)
  247.  
  248.    flagcommand=0;                       // Desactivo flag de comando pendiente.
  249.  
  250.    for(i=0;i<lenbuff;i++){             // Bucle que pone a 0 todos los
  251.       arg[i]=0x00;                     // caracteres en el argumento
  252.    }
  253.  
  254.    if(cbuff[0]=='C'&&cbuff[1]=='1'&&cbuff[2]=='_'&&cbuff[3]=='O'&&cbuff[4]=='N'&&cbuff[5]==0x00){// Comparo inicio del buffer con comando "A1"
  255.  
  256.       flag=1;          // Activamos el flag para detectar comando valido
  257.       calentador_ON;  // activamos puerta RB1 --> Calentador ON
  258.       disable_interrupts(int_ad);
  259.       printf("CALENTADOR --> Activado"); // mostramos stado calentador por RS232
  260.       enable_interrupts(int_AD);  // Habilita las interrupciones globales
  261.       estado_calentador=1;             // variable estado_calentador=ON
  262.       write_eeprom(0,estado_calentador);  // Escribe en la primera posición de la eeprom el estado del calentador
  263.    }
  264.    if(cbuff[0]=='C'&&cbuff[1]=='1'&&cbuff[2]=='_'&&cbuff[3]=='O'&&cbuff[4]=='F'&&cbuff[5]=='F'&&cbuff[6]==0x00){
  265.  
  266.       flag=1;      // Activamos el flag para detectar comando valido
  267.       calentador_OFF;   // desactivamos puerta RB1--> calentador OFF
  268.       disable_interrupts(int_ad);
  269.       printf("CALENTADOR --> Desactivado");   // Mostramos stdo calentador RS232
  270.       enable_interrupts(int_AD);  // Habilita las interrupciones globales
  271.       estado_calentador=0;                       // Variable calentador=OFF
  272.       write_eeprom(0,estado_calentador);   // Escribe en la primera posición de la eeprom el estado del calentador
  273.    }
  274.    if(cbuff[0]=='S'&&cbuff[1]=='T'&&cbuff[2]=='D'&&cbuff[3]=='O'&&cbuff[4]==0x00){
  275.  
  276.       flag=1;            // Activamos el flag para detectar comando valido
  277.       disable_interrupts(int_ad);
  278.       estado_calentador=read_eeprom(0);   // Leemos en la primera posicion de la EEPROM el estado del calentador    
  279.       if (estado_calentador==1)   printf("CALENTADOR --> ESTADO ON");      // Escribimos por pantalla el estado del calentador
  280.          else  printf("CALENTADOR --> ESTADO OFF");
  281.       enable_interrupts(int_AD);  // Habilita las interrupciones globales
  282.    }
  283.    if(cbuff[0]=='V'&&cbuff[1]=='_'&&cbuff[2]=='C'&&cbuff[3]=='A'&&cbuff[4]=='D'&&cbuff[6]==0x00){
  284.  
  285.       flag=1;      // Activamos el flag para detectar comando valido
  286.       toma_adc_y_transmite();
  287.    }      
  288.    if(cbuff[0]=='B'&&cbuff[1]=='O'&&cbuff[2]=='R'&&cbuff[3]=='R'&&cbuff[4]=='A'&&cbuff[5]=='R'&&cbuff[6]=='_' &&cbuff[7]=='E'&&cbuff[8]==0x00){
  289.  
  290.       flag=1;       // Activamos el flag para detectar comando valido
  291.       calentador_OFF;    // desactivamos puerta RB1-->calentador OFF
  292.       write_eeprom(0,0);     // Inicializamos a 0 las dos posiciones utilizadas
  293.       write_eeprom(1,0);
  294.       disable_interrupts(int_ad);
  295.       printf("EEPROM BORRADA");
  296.       enable_interrupts(int_AD);  // Habilita las interrupciones globales
  297.    }  
  298.    if(cbuff[0]=='R'&&cbuff[1]=='E'&&cbuff[2]=='S'&&cbuff[3]=='E'&&cbuff[4]=='T'&&cbuff[5]==0x00){
  299.  
  300.       write_eeprom(0,estado_calentador);   // Guardamos en la EEPROM el estado del calentador
  301.       flag_reset=1;                    // Activamos el flag de reset por consola
  302.       write_eeprom(1,flag_reset);      // Guardamos el valor en la EEPROM
  303.       disable_interrupts(int_ad);
  304.       printf("RESET");
  305.       enable_interrupts(int_AD);  // Habilita las interrupciones globales
  306.      // Bucle infinito para que el Watchdog resetee mi chiporro por Azicuetano
  307.       do{
  308.      
  309.       }while(true);
  310.    }
  311.    if(cbuff[0]=='V'&&cbuff[1]=='E'&&cbuff[2]=='R'&&cbuff[3]=='S'&&cbuff[4]=='I'&&cbuff[5]=='O'&&cbuff[6]=='N'&&cbuff[8]==0x00){
  312.  
  313.       flag=1;   // Activamos el flag para detectar comando valido
  314.       disable_interrupts(int_ad);
  315.       printf("V3.5"); // Muestra por la RS232 lña versión del programa.
  316.       // lo utilizo mucho por que en Labview cada x tiempo mando el comando "VERSION"
  317.       // compruebo la comunicación si esta OK.
  318.       enable_interrupts(int_AD);  // Habilita las interrupciones globales
  319.    }  
  320.    if (flag==1){         // Si flag==1 es que se ha metido en algún if
  321.       flag=0;            // pone a cero el flag
  322.      }
  323.      else{
  324.          disable_interrupts(int_ad);
  325.          printf("Comando no reconocido");  // Comando no reconocido
  326.          enable_interrupts(int_AD);  // Habilita las interrupciones globales
  327.      }
  328. // Una vez procesado el comando borrams por buffer de la RS232
  329.  
  330.    inicbuff();     // Borro buffer.
  331. }
  332.  
  333. ////////////////////////////////////////////////////////////////////////////////
  334. //                  PROGRAMA PRINCIPAL VOID MAIN()                            //
  335. ////////////////////////////////////////////////////////////////////////////////
  336.  
  337. void main() {
  338.  
  339.    port_b_pullups(FALSE);   // Resistencias de Pullup desactivadas
  340.    set_tris_B(0b0000001);   // Configuramos entradas y salidas. RB1:7-->Salida ; RB0--> Entrada
  341.    
  342.    setup_adc(ADC_CLOCK_DIV_32);
  343.    setup_adc_ports(AN0_AN1_AN3);
  344.    
  345.    flag_reset=read_eeprom(1);    //leemos la variable reset en eeprom
  346.    if (flag_reset==1){
  347.       printf("reset por consola");
  348.    }
  349.    
  350.    calentador_OFF;
  351.  
  352.    inicbuff();          // Borra buffer al inicio
  353.  
  354.    enable_interrupts(int_rda);
  355.    enable_interrupts(int_ad);
  356.    
  357. //   setup_wdt(WDT_18MS);  // Configuramos el Watchdog para que salte a los 144ms
  358. //   RESTART_WDT();        // Incia o watch-dog timer
  359.    
  360.    enable_interrupts(global);
  361.  
  362.    canal=0;
  363.    Read_ADC(ADC_START_ONLY); // Inicia el CAD por int.
  364.  
  365.    printf("\n\ AD - LM35a - Monitor\n\n"); // Presenta menu
  366.    
  367.    lcd_init();
  368.    lcd_setcursor(0,0);
  369.    lcd_gotoxy(1,1);
  370.    printf(lcd_putc,"CAD Temp. LM35a \n  foro todopic"); //muestra por la LCD
  371.    delay_ms(3000);
  372.    lcd_gotoxy(1,1);
  373.    printf(lcd_putc,"  V2.0 umalrovi \n  foro todopic"); //muestra por la LCD
  374.    delay_ms(3000);
  375.    
  376.    do {  
  377.       visualiza_parametros_LCD();    
  378.       if (flagcommand==1){    
  379.          procesa_comando();
  380.       }
  381.    } while (TRUE);
  382. }
  383.  

Según mi compi azicuetano, y yo le doy la razón, NO HABILITAR EL WATCH_DOG UNA VEZ TERMINADA LA PLICACIÓN ES UN GRAN ERROR. Así que me he propuesto habilitarlo en este programa y no lo he conseguido.
Lo único que tengo que hacer es:
1.- cambiar la línea 43 por
Código: [Seleccionar]
#fuses HS,WDT,NOPROTECT,NOLVP,PUT,BROWNOUT2.- quitar el comentario de la línea 357 para configurarlo
Código: [Seleccionar]
setup_wdt(WDT_18MS);3.- Ir refrescandolo en el programa poniendo
Código: [Seleccionar]
RESTART_WDT();
En otros programas que he realizado y activado el watchdog, no me ha dado ningún problema pero en este caso si. Normalmente lo que hago es saber el tiempo que tarda mi programa sin resetearlo, es decir, pruebo a configurar mi watchdog con 18ms si mi programa está sucesivamente reseandose, le subo el tiempo a 36ms así sucesivamente hasta que deje de resetearse y limpiando estrategicamente el watchdog en los bucles.

Pues bien en este programa configuro el watchdog al mínimo tiempo posible (18ms) y veo que no se resetea, el programa funciona como si NO estuviera activado el watdog y sin limpiarlo (restart_wdt()) por lo tanto veo que lo configuro mal ya que mi programa debe resetearse continuamente!!!

a ver si alguien me ayuda y me explica que narices pasa.Saludos!!

Alf
« Última modificación: 19 de Noviembre de 2007, 14:40:55 por umalrovi »
Aplicaciones Electrónicas
http://www.neoingenia.com/

Desconectado Azicuetano

  • Moderadores
  • PIC24H
  • *****
  • Mensajes: 1020
    • Aplicaciones Electrónicas en Alicante.
Temperatura y Luminosidad con un LM35a y una LDR (CAD CON INTERRUPCIÓN)
« Respuesta #13 en: 19 de Noviembre de 2007, 13:56:26 »
Hola Alfon!

Mira esto:

#use delay(clock=20000000,RESTART_WDT) // Oscilador a 20 Mhz y limpia en delay

Lo que pasa es que el compilador por el hecho de tener la instrucción 'RESTART_WDT' en el '#use delay' te resetea el WDT el sólo.

Si pones eso no necesitas refrescarlo tú, pero, no te lo aconsejo. Tú aplicación es demasiado seria como para no ponerlo perfecto (lo más ajustado posible).

Ale! Ya hablamos.


Un saludo desde Alicante.

Desconectado umalrovi

  • Colaborador
  • PIC16
  • *****
  • Mensajes: 158
    • Aplicaciones Electrónicas
Temperatura y Luminosidad con un LM35a y una LDR (CAD CON INTERRUPCIÓN)
« Respuesta #14 en: 19 de Noviembre de 2007, 14:34:12 »
Buenas Iván,

me alegra verte por aquí, después de la llamadita al movil pidiéndote socoroooo!!! jejeje.

En un primer momento no tenía pueso el:
Código: [Seleccionar]
#use delay(clock=20000000,RESTART_WDT) // Oscilador a 20 Mhz y limpia en delaylo que pasa es que antes de postear la duda en el foro me he puesto a buscar a ver si a alguien le había pasado lo mismo y se me ha colado a la hora de pegar el código.

Pero bueno si quitamos el RESTART_WDT dentro del use delay y lo dejamos así:
Código: [Seleccionar]
#use delay(clock=20000000)me pasa lo mismo sin limpiar el watchdog en ninguna parte del código. En teoría mi pic se debe resetear porque tiene un tiempo muy pequeño!!!
Hay algo que hago mal a la hora de declarar el watchdog!!!

Saludos.
« Última modificación: 20 de Noviembre de 2007, 10:05:19 por umalrovi »
Aplicaciones Electrónicas
http://www.neoingenia.com/