TODOPIC

Microcontroladores PIC => Todo en microcontroladores PIC => Mensaje iniciado por: johenrod en 02 de Mayo de 2022, 12:14:17

Título: Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 02 de Mayo de 2022, 12:14:17
cordial saludo, una vez mas solicitando de vuestra ayuda.
tengo una interrupción para recibir un dato por el puerto serie, lo almaceno en una variable si proceso llla informacion antes de salir de la interrupcion me funciona pero si leo esta variable dentro de un switch case se pierde el dato, dejo ambos ejemplos, gracias de antemano por la ayuda.
así no funciona
Código: C
  1. int valor=0;
  2.    int flag=0;
  3.    int1 flag2=0;
  4.    char guardar;
  5.    //char rol=0;
  6.    //char cadena1[20];
  7.    // declaracion funciones
  8.       void ret1        (); // retardo general secuencias
  9.       void secuencia1  ();
  10.  
  11.    #int_RDA
  12.    void RDA_isr(void)
  13.    {
  14.  
  15.     //valor=0;
  16.   if(kbhit())//verifico si el dato ya esta disponible
  17.  {
  18.   valor=getc();//adquiero el dato
  19.    flag=1;
  20.  }
  21.      
  22.    }
  23.  
  24.   if (flag==1)
  25.       {
  26.         switch(valor)// [b]aqui se piede el contenido de valor[/b]
  27.          {  
  28.          case 'a':
  29.         secuencia1();                  
  30.          break;  
  31.          case 'b':  
  32. ...........................

así funciona
Código: C++
  1. #int_RDA
  2.    void RDA_isr(void)
  3.    {
  4.  
  5.     //valor=0;
  6.   if(kbhit())//verifico si el dato ya esta disponible
  7.  {
  8.   valor=getc();//adquiero el dato
  9.    flag=1;
  10.  }
  11.      if (valor=='a')
  12. {
  13. secuencia1();  
  14. }
  15.    }
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: DominusDRR en 02 de Mayo de 2022, 12:20:06
Cita de: johenrod en 02 de Mayo de 2022, 12:14:17
cordial saludo, una vez mas solicitando de vuestra ayuda.
tengo una interrupción para recibir un dato por el puerto serie, lo almaceno en una variable si proceso llla informacion antes de salir de la interrupcion me funciona pero si leo esta variable dentro de un switch case se pierde el dato, dejo ambos ejemplos, gracias de antemano por la ayuda.
así no funciona
Código: C
  1. int valor=0;
  2.    int flag=0;
  3.    int1 flag2=0;
  4.    char guardar;
  5.    //char rol=0;
  6.    //char cadena1[20];
  7.    // declaracion funciones
  8.       void ret1        (); // retardo general secuencias
  9.       void secuencia1  ();
  10.  
  11.    #int_RDA
  12.    void RDA_isr(void)
  13.    {
  14.  
  15.     //valor=0;
  16.   if(kbhit())//verifico si el dato ya esta disponible
  17.  {
  18.   valor=getc();//adquiero el dato
  19.    flag=1;
  20.  }
  21.      
  22.    }
  23.  
  24.   if (flag==1)
  25.       {
  26.         switch(valor)// [b]aqui se piede el contenido de valor[/b]
  27.          {  
  28.          case 'a':
  29.         secuencia1();                  
  30.          break;  
  31.          case 'b':  
  32. ...........................

así funciona
Código: C++
  1. #int_RDA
  2.    void RDA_isr(void)
  3.    {
  4.  
  5.     //valor=0;
  6.   if(kbhit())//verifico si el dato ya esta disponible
  7.  {
  8.   valor=getc();//adquiero el dato
  9.    flag=1;
  10.  }
  11.      if (valor=='a')
  12. {
  13. secuencia1();  
  14. }
  15.    }

¿Será porque valor lo estas evaluando fuera de la función RDA_isr?

O se tal vez debe ser así:

Código: C
  1. void RDA_isr(void)
  2.  {
  3.  
  4.     //valor=0;
  5.     if(kbhit())//verifico si el dato ya esta disponible
  6.    {
  7.         valor=getc();//adquiero el dato
  8.         flag=1;
  9.     }
  10.      
  11.     //} <============= aquí estás cerrando la llave de la función y valor queda fuera de la función
  12.  
  13.     if (flag==1)
  14.     {
  15.         switch(valor)// [b]aqui se piede el contenido de valor[/b]
  16.         {  
  17.         case 'a':
  18.            secuencia1();                  
  19.           break;  
  20.          case 'b':  
  21.          .......
  22.          }
  23.  
  24. }// <=== aquí deberías cerrar la función RDA_isr
  25. ...........................
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 02 de Mayo de 2022, 12:39:45
DominusDRR, cordial saludo, gracias por tu interés en ayudarme.
el switch esta muy por debajo en el programa lo que pasa es que lo coloque seguido para no colocar todo el programa que es extenso.
y no coloco el switch dentro de la interrupción ya que la idea es salir rapidito.
( la idea es saber por que se pierde el valor al llegar al switch case) de hecho trato de imprimir la variable y no sale nada, "se pierde el dato"
putc(valor);
Código: C++
  1. int valor=0;
  2.    int flag=0;
  3.    int1 flag2=0;
  4.    char guardar;
  5.    //char rol=0;
  6.    //char cadena1[20];
  7.    // declaracion funciones
  8.       void ret1        (); // retardo general secuencias
  9.       void secuencia1  ();
  10.  
  11.    #int_RDA
  12.    void RDA_isr(void)
  13.    {
  14.  
  15.     //valor=0;
  16.   if(kbhit())//verifico si el dato ya esta disponible
  17.  {
  18.   valor=getc();//adquiero el dato
  19.    
  20.    flag=1;
  21.  }
  22.  
  23.  
  24.      
  25.    }
  26.    
  27.    
  28.    
  29.  
  30.  
  31.    // VOID MAIN //
  32.    void main()
  33.    {
  34.    SET_TRIS_a(0B00000000);
  35.    SET_TRIS_b(0B00000000);
  36.    SET_TRIS_c(0B10011111);
  37.    SET_TRIS_e(0B1);
  38.    setup_adc_ports(NO_ANALOGS);
  39.    setup_comparator(NC_NC_NC_NC);
  40.    portA=0x00;
  41.    portB=0x00;
  42.  
  43.    enable_interrupts(INT_RDA); //HAbilita interrupcion por puerto serial
  44.    enable_interrupts(GLOBAL);  // Habilita las interrupcciones globales
  45.  
  46.    s=80;
  47.  
  48.  
  49.    while(TRUE)
  50.    {
  51.  
  52.  
  53.  
  54.    // VALOR INTERUPCION /
  55.   if (flag==1)
  56.       {
  57.         // if(valor=='a')
  58.        //  porta=0;
  59.         //secuencia3();
  60.         //porta=0xff;
  61.         // delay_ms(1000);
  62.         putc('m');
  63.          putc(valor);
  64.         switch(valor)// aqui se piede el contenido sde valor
  65.          {  
  66.          case 'a':  
  67.            // putc('m');
  68.         // guardar=valor;  
  69.         puerto=0;
  70.          secuencia1();                  
  71.          break;  
  72.          case 'b':  
  73.          puerto=0;
  74.          guardar=valor;
  75.          secuencia2();
  76.          break;
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: DominusDRR en 02 de Mayo de 2022, 13:07:16
Cita de: johenrod en 02 de Mayo de 2022, 12:14:17
cordial saludo, una vez mas solicitando de vuestra ayuda.
tengo una interrupción para recibir un dato por el puerto serie, lo almaceno en una variable si proceso llla informacion antes de salir de la interrupcion me funciona pero si leo esta variable dentro de un switch case se pierde el dato, dejo ambos ejemplos, gracias de antemano por la ayuda.
así no funciona
Código: C
  1. int valor=0;
  2.    int flag=0;
  3.    int1 flag2=0;
  4.    char guardar;
  5.    //char rol=0;
  6.    //char cadena1[20];
  7.    // declaracion funciones
  8.       void ret1        (); // retardo general secuencias
  9.       void secuencia1  ();
  10.  
  11.    #int_RDA
  12.    void RDA_isr(void)
  13.    {
  14.  
  15.     //valor=0;
  16.   if(kbhit())//verifico si el dato ya esta disponible
  17.  {
  18.   valor=getc();//adquiero el dato
  19.    flag=1;
  20.  }
  21.      
  22.    }
  23.  
  24.   if (flag==1)
  25.       {
  26.         switch(valor)// [b]aqui se piede el contenido de valor[/b]
  27.          {  
  28.          case 'a':
  29.         secuencia1();                  
  30.          break;  
  31.          case 'b':  
  32. ...........................

así funciona
Código: C++
  1. #int_RDA
  2.    void RDA_isr(void)
  3.    {
  4.  
  5.     //valor=0;
  6.   if(kbhit())//verifico si el dato ya esta disponible
  7.  {
  8.   valor=getc();//adquiero el dato
  9.    flag=1;
  10.  }
  11.      if (valor=='a')
  12. {
  13. secuencia1();  
  14. }
  15.    }

¿Por qué ejecutas putc antes del switch?

¿Será que esa función borra el contenido?

Código: C
  1. putc(valor);
  2. switch(valor)

¿Qué tal si al guardas en otra variable antes del putc?


Código: C
  1. valor2 = valor
  2. putc(valor);
  3. switch(valor2)
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 02 de Mayo de 2022, 13:18:08
saludos,
putc(valor); la coloque  para hallar el problema pero no se necesita, tambien la copie en otra variable (tal cual lo hiciste) y sigue sin trabajar.
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 02 de Mayo de 2022, 13:29:56
si coloco el switch dentro de la interrupción trabaja bien.
pero deseo saber que es lo que sucede que se pierde el contenido de la variable (valor)
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: DominusDRR en 02 de Mayo de 2022, 14:03:49
Cita de: johenrod en 02 de Mayo de 2022, 13:29:56
si coloco el switch dentro de la interrupción trabaja bien.
pero deseo saber que es lo que sucede que se pierde el contenido de la variable (valor)

Esa clase de error y otros recuerdo que descubrí en el CCS (PICC) hace muchos años y por esa razón lo dejé para cambiarme a C18 (actual XC8).

Pero ya es muchos años de eso, es de suponer que ya no debería tener esos errores.

Tal vez deberías declararla como static

La otra opción sería seguirle el rastro en ensamblador para determinar que sucede.
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: DominusDRR en 02 de Mayo de 2022, 14:05:17
Cita de: DominusDRR en 02 de Mayo de 2022, 14:03:49
Cita de: johenrod en 02 de Mayo de 2022, 13:29:56
si coloco el switch dentro de la interrupción trabaja bien.
pero deseo saber que es lo que sucede que se pierde el contenido de la variable (valor)

Esa clase de error y otros recuerdo que descubrí en el CCS (PICC) hace muchos años y por esa razón lo dejé para cambiarme a C18 (actual XC8).

Pero ya es muchos años de eso, es de suponer que ya no debería tener esos errores.

Tal vez deberías declararla como static

La otra opción sería seguirle el rastro en ensamblador para determinar que sucede.

Tal vez deberías compartir el código del proyecto completo. Hay quienes que podrían descargarlo y determinar si les pasa lo mismo.
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: KILLERJC en 02 de Mayo de 2022, 14:17:57
Toda variable que se use en una interrupcion y luego en otro lado, debe ser declarada como "volatile", para evitar problemas con los optimizadores.
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 02 de Mayo de 2022, 14:58:51
Cita de: KILLERJC en 02 de Mayo de 2022, 14:17:57
Toda variable que se use en una interrupcion y luego en otro lado, debe ser declarada como "volatile", para evitar problemas con los optimizadores.
muchas gracias por tu respuesta.
en CCS se podria y donde se declararía?
lo hice asi y no me funciono..
volatile int valor;
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: Eduardo2 en 02 de Mayo de 2022, 15:10:01
Deberías hacer caso a la última sugerencia de DominusDRR
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: DominusDRR en 02 de Mayo de 2022, 15:25:28
Cita de: johenrod en 02 de Mayo de 2022, 14:58:51
Cita de: KILLERJC en 02 de Mayo de 2022, 14:17:57
Toda variable que se use en una interrupcion y luego en otro lado, debe ser declarada como "volatile", para evitar problemas con los optimizadores.
muchas gracias por tu respuesta.
en CCS se podria y donde se declararía?
lo hice asi y no me funciono..
volatile int valor;

Me parece que volatile int valor es lo mismo que int valor
Sólo por probar a ver que pasa, sugerí: static int valor
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 02 de Mayo de 2022, 15:33:36
haciendo caso...
Código: C++
  1. #include <16F1936.h>
  2.    #include <stdio.h>
  3.    #include <stdlib.h>
  4.    #include <string.h>
  5.    #fuses noDEBUG   //  debug - in circuit debugger enabled on RB6 and RB7 - DISABLED
  6.    #fuses noLVP     //  LVP - low voltage enable - DISABLED
  7.    #fuses noFCMEN   //  Fail safe clock monitor - DISABLED
  8.    #fuses noIESO    //  IESO - internal / external switch over DISABLED
  9.    #fuses noBROWNOUT  //  Brown out reset selection bits - 11 BOR  DISABLED
  10.    #fuses CPD     //  CPD - date code protect DISABLED
  11.    #fuses PROTECT //  CP - code protect DISABLED
  12.    #fuses noMCLR      //  MCLRE - RE3 is MCLR
  13.    #fuses noPUT     //  PWRTE - power up timer enable bit DISABLED
  14.    #fuses noWDT    //  WDTE - watch dog enable bit - not enabled here, in code below
  15.    #fuses INTRC_IO   //  FOSC - oscillator - set to INTRC_IO-- defaults the clock to 4Mhz
  16.    #use delay(internal=8000000)
  17.  
  18.    #use rs232(baud=9600,parity=N,xmit=pin_c6,rcv=pin_c7,bits=8,errors)
  19.  
  20.    
  21.    #byte portA= 0x0C
  22.    #byte portB= 0x0D
  23.    #byte portC= 0x0E    
  24.    #byte portE= 0x10
  25.    # use fast_io(a)
  26.    # use fast_io(b)
  27.  
  28.                
  29.                          
  30.    //   *******************************************************************                        
  31.  
  32.  
  33.    signed  int8 i=0;        // variable para las secuencias  
  34.            int8 valor=0;
  35.            int flag=0;
  36.    
  37.    
  38.    
  39.    // declaracion funciones
  40.  
  41.       void secuencia1  ();
  42.  
  43.  
  44.    #int_RDA
  45.    void RDA_isr(void)
  46.    {
  47.        if(kbhit())//verifico si el dato ya esta disponible
  48.        {
  49.        valor=getc();//adquiero el dato
  50.        //guardar =valor;  
  51.        flag=1;
  52.        }
  53.  
  54.  
  55.      
  56.    }
  57.    
  58.  
  59.  
  60.    // VOID MAIN //
  61.    void main()
  62.    {
  63.    SET_TRIS_a(0B00000000);
  64.    SET_TRIS_b(0B00000000);
  65.    SET_TRIS_c(0B10011111);
  66.    SET_TRIS_e(0B1);
  67.    setup_adc_ports(NO_ANALOGS);
  68.    setup_comparator(NC_NC_NC_NC);
  69.    portA=0x00;
  70.    portB=0x00;
  71.  
  72.    enable_interrupts(INT_RDA); //HAbilita interrupcion por puerto serial
  73.    enable_interrupts(GLOBAL);  // Habilita las interrupcciones globales
  74.  
  75.  
  76.  
  77.  
  78.    while(TRUE)
  79.    {
  80.              
  81.   //****************************                  
  82.  
  83.     //  Reset_cpu();
  84.              
  85.  
  86.    //*********************************
  87.  
  88.  
  89.  
  90.    // VALOR INTERUPCION /
  91.    if (flag==1)
  92.       {
  93.  
  94.          switch(valor)// aqui se piede el contenido sde valor
  95.          {  
  96.          case 'a':  
  97.          secuencia1();                  
  98.          break;  
  99.          }  
  100.  
  101.      flag=0;
  102.      valor=0;
  103.    
  104.     }
  105.  
  106.  
  107.      
  108.    }// while true
  109.    }//main
  110.  
  111.  
  112.  
  113.      
  114.  
  115.     void secuencia1()
  116.      
  117.     {    
  118.          for (i=0;i<=5;i++)
  119.          {
  120.           porta=0xff;
  121.           portb=0xff;
  122.           delay_ms(50);
  123.           porta=0x00;
  124.           portb=0x00;
  125.           delay_ms(50);        
  126.          }
  127.    delay_ms(400);
  128.     }
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 02 de Mayo de 2022, 15:39:10
Cita de: DominusDRR en 02 de Mayo de 2022, 15:25:28
Me parece que volatile int valor es lo mismo que int valor
Sólo por probar a ver que pasa, sugerí: static int valor
sigue igual, no hay cambios.
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: DominusDRR en 02 de Mayo de 2022, 15:45:23
Cita de: johenrod en 02 de Mayo de 2022, 15:39:10
Cita de: DominusDRR en 02 de Mayo de 2022, 15:25:28
Me parece que volatile int valor es lo mismo que int valor
Sólo por probar a ver que pasa, sugerí: static int valor
sigue igual, no hay cambios.

Miré el ensamblador que genera para determinar que sucede con esa variable, o espere a alguien que simule su proyecto.
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: Eduardo2 en 02 de Mayo de 2022, 15:46:14
Yo simulo eso y no se pierde nada...
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 02 de Mayo de 2022, 15:54:34
Cita de: DominusDRR en 02 de Mayo de 2022, 15:45:23
Miré el ensamblador que genera para determinar que sucede con esa variable, o espere a alguien que simule su proyecto.
0 errors
0 warnings
build successful
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 02 de Mayo de 2022, 15:57:58
Cita de: Eduardo2 en 02 de Mayo de 2022, 15:46:14
Yo simulo eso y no se pierde nada...
le estoy enviando datos por el puerto serie  y  si me pego a enviar  a,a,a,a,a,a,a,a,a, en algún momento lo hace, tal vez en el hardware se comporta diferente que en la simulación.
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: DominusDRR en 02 de Mayo de 2022, 16:00:31
Cita de: johenrod en 02 de Mayo de 2022, 15:54:34
Cita de: DominusDRR en 02 de Mayo de 2022, 15:45:23
Miré el ensamblador que genera para determinar que sucede con esa variable, o espere a alguien que simule su proyecto.
0 errors
0 warnings
build successful

Hombre, el lenguaje ensamblador que genera el código. En alguna parte debes tener una opción para desensamblar el código compilado.
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: Eduardo2 en 02 de Mayo de 2022, 16:18:32
Cita de: johenrod en 02 de Mayo de 2022, 15:57:58
....
le estoy enviando datos por el puerto serie  y  si me pego a enviar  a,a,a,a,a,a,a,a,a, en algún momento lo hace, tal vez en el hardware se comporta diferente que en la simulación.
Con los delays que tenés en secuencia() tranquilamente podés perder varios caracteres.
Y no lo solucionás con un buffer porque secuencia() te está limitando  la cantidad de caracteres a leer por segundo.
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: DominusDRR en 02 de Mayo de 2022, 16:34:44
Cita de: johenrod en 02 de Mayo de 2022, 15:54:34
Cita de: DominusDRR en 02 de Mayo de 2022, 15:45:23
Miré el ensamblador que genera para determinar que sucede con esa variable, o espere a alguien que simule su proyecto.
0 errors
0 warnings
build successful

.

Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 02 de Mayo de 2022, 17:21:58
Cita de: DominusDRR en 02 de Mayo de 2022, 16:34:44

Miré el ensamblador que genera para determinar que sucede con esa variable, o espere a alguien que simule su proyecto.

que pena,,  no sabia como se hacia, lo realice pero no me deja subirlo porque tiene mas de 4000 caracteres, voy a buscar la forma
  - Tienes que ingresar para ver archivos adjuntos -  
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 02 de Mayo de 2022, 17:32:19
Cita de: Eduardo2 en 02 de Mayo de 2022, 16:18:32
Cita de: johenrod en 02 de Mayo de 2022, 15:57:58
....
le estoy enviando datos por el puerto serie  y  si me pego a enviar  a,a,a,a,a,a,a,a,a, en algún momento lo hace, tal vez en el hardware se comporta diferente que en la simulación.
Con los delays que tenés en secuencia() tranquilamente podés perder varios caracteres.
Y no lo solucionás con un buffer porque secuencia() te está limitando  la cantidad de caracteres a leer por segundo.
si tienes razón con los delay lo que pasa es que no estoy enviando datos constantemente dije que enviaba constantemente ,a,a, para saber o buscar el problema. lo que hago es envio un caracter, en switch ve cual concuerda y va a la secuencia respectiva, yo espero a que termine para enviarle un nuevo comando por que como bien dices mientras este en la función o delay de pierden. en el ejemplo que subí solo tengo un switch case y trabaja pero ya completo no.
acá esta completo.
Código: C++
  1. #include <16F1936.h>
  2.    #include <stdio.h>
  3.    #include <stdlib.h>
  4.    #include <string.h>
  5.    #fuses noDEBUG   //  debug - in circuit debugger enabled on RB6 and RB7 - DISABLED
  6.    #fuses noLVP     //  LVP - low voltage enable - DISABLED
  7.    #fuses noFCMEN   //  Fail safe clock monitor - DISABLED
  8.    #fuses noIESO    //  IESO - internal / external switch over DISABLED
  9.    #fuses noBROWNOUT  //  Brown out reset selection bits - 11 BOR  DISABLED
  10.    #fuses CPD     //  CPD - date code protect DISABLED
  11.    #fuses PROTECT //  CP - code protect DISABLED
  12.    #fuses noMCLR      //  MCLRE - RE3 is MCLR
  13.    #fuses noPUT     //  PWRTE - power up timer enable bit DISABLED
  14.    #fuses noWDT    //  WDTE - watch dog enable bit - not enabled here, in code below
  15.    #fuses INTRC_IO   //  FOSC - oscillator - set to INTRC_IO-- defaults the clock to 4Mhz
  16.    #use delay(internal=8000000)
  17.  
  18.    #use rs232(baud=9600,parity=N,xmit=pin_c6,rcv=pin_c7,bits=8,errors)
  19.  
  20.    
  21.    #byte portA= 0x0C
  22.    #byte portB= 0x0D
  23.    #byte portC= 0x0E    
  24.    #byte portE= 0x10
  25.    # use fast_io(a)
  26.    # use fast_io(b)
  27.  
  28.    #define izq    pin_c0
  29.    #define medias pin_c1 //
  30.    #define acc    pin_c2
  31.    #define der    pin_c3
  32.    #define stop   pin_c4
  33.    
  34.   // #define speed50  delay_ms(50)
  35.    //#define speed100 delay_ms(100)
  36.   // #define speed200 delay_ms(200)
  37.  //  #define speed300 delay_ms(300)
  38.   // #define speed400 delay_ms(400)
  39.  
  40.  // #byte valor=0
  41.  
  42.   // typedef volatile char valor;
  43.  
  44.  
  45.  
  46.  
  47.      
  48.  //secuencia 9
  49.  byte const s1d7[]={0b00000001,0b00000010,0b00000100,0b00001001,0b00010010,0b00100100,0b01001001,0b10010010
  50.                     0b00100100,0b01001000,0b10010000,0b00100000,0b01000000,0b10000000,0b00000000};//0-14
  51.                          
  52.     //    byte const s2d7[]={0,50,100,150,200,255};//0-14
  53.      //   byte const s3d7[]={255,200,150,100,50,0};//0-14        
  54.        
  55.      // secuencia10
  56.      byte const s2d7[]={0,127,255};//0-14
  57.      byte const s3d7[]={255,127,0};//0-14  
  58.                            
  59.      // byte const valor;          
  60.                          
  61.                
  62.                          
  63.                          
  64.    //   *******************************************************************                        
  65.  
  66.    // variables para pwm
  67.      signed int16 pwmh =0;
  68.      signed int16 pwml =0;  
  69.    //*********************
  70.  
  71.    int1  doble=0x01;         // en 0 solo ascendente en 1 asciende y regresa
  72.    signed  int8 i=0;        // variable para las secuencias  
  73.    signed  int8 j=0;       // variable para las secuencias  
  74.    signed  int8 k=0;      // variable para las secuencias  
  75.    signed  int8 m=0;     // variable para numero de salidas //  para secuencia 9
  76.    signed  int8 n=7;    // numero de salidas
  77.   // int n=num;        // numero de salidas que se van a utilizar
  78.    int8 mezcla =0;    // alberga la info del puerto para luego pasarla a los puertos a y b
  79.    signed int16 s;   // tiempo de retardo
  80.    int puerto =1;   // 0 a y b / 1 a / 2 el b elige  el puerto
  81.    //int puerto1 =1; // 0 a y b / 1 a / 2 el b elige  el puerto
  82.    signed  int16 f=0; // para secuencia10 pwm
  83.            int g=0;   // para secuencia10 pwm
  84.    signed int intensidad=0;
  85.    int8 valor=0;
  86.  
  87.    int flag=0;
  88.    int1 flag2=0;
  89.    int guardar;
  90.   // char rol=0;
  91.    
  92.  
  93.      // static int valor;
  94.    
  95.    
  96.    // declaracion funciones
  97.       void ret1        (); // retardo general secuencias
  98.       void secuencia1  ();
  99.       void secuencia2  ();
  100.       void secuencia3  ();
  101.       void secuencia4  ();      
  102.       void secuencia5  ();
  103.       void secuencia6  ();
  104.       void secuencia7  ();
  105.       void secuencia8  ();
  106.       void secuencia9  ();
  107.       void secuencia10 ();
  108.       void secuencia11 ();
  109.       void salida      (); // funcion para mostrar los efectos
  110.       void dimmer      ();
  111.       void suiche();
  112.    //*******************
  113.       void freno();
  114.       void frenoflash();
  115.  
  116.    #int_RDA
  117.    void RDA_isr(void)
  118.    {
  119.  
  120.     //valor=0;
  121.   if(kbhit())//verifico si el dato ya esta disponible
  122.  {
  123.    valor=0;
  124.     valor=getc();//adquiero el dato
  125.     //guardar =valor;
  126.    
  127.     flag=1;
  128.  
  129.  }
  130.  
  131. /*
  132.          switch(valor)// aqui se piede el contenido sde valor
  133.          {  
  134.          case 'a':
  135.        
  136.          //putc('m');
  137.          // guardar=valor;  
  138.          puerto=0;
  139.          secuencia1();                  
  140.          break;  
  141.          case 'b':  
  142.          guardar=valor;
  143.          secuencia2();
  144.          break;
  145.          }
  146.   guardar =valor;
  147. */
  148.  
  149.  
  150.  
  151.  
  152.  
  153.  
  154.  
  155.   //  valor=getc(); //Captura el dato recibido del PIC 1
  156.  //  guardar=getc();
  157.  // flag=1;
  158.     //guardar =valor;
  159.      //putc(valor);
  160.    
  161.      
  162.      
  163.    }
  164.    
  165.    
  166.    
  167.   /*
  168.   bit_set(porta,4) ;
  169.     //write_eeprom(0x01,valor);
  170.     delay_ms(100);
  171.     //valor=read_eeprom(0);
  172. bit_clear(porta,4) ;
  173. delay_ms(100);
  174. */
  175.  
  176.  
  177.    // EEPROM DISTRIBUCION //
  178.    /*
  179.    0 u  pwmh
  180.    1 t  pwml
  181.    2 v SECUENCIA DIRECCIONALES
  182.    3 w SECUENCIA ESTACIONARIAS
  183.    4 x SECUENCIA FRENO
  184.    5 y SECUENCIA MEDIAS
  185.    6 z SECUENCIA SALUDO
  186.  
  187.    */
  188.  
  189.  
  190.  
  191.    // VOID MAIN //
  192.    void main()
  193.    {
  194.    SET_TRIS_a(0B00000000);
  195.    SET_TRIS_b(0B00000000);
  196.    SET_TRIS_c(0B10011111);
  197.    SET_TRIS_e(0B1);
  198.    setup_adc_ports(NO_ANALOGS);
  199.    setup_comparator(NC_NC_NC_NC);
  200.    portA=0x00;
  201.    portB=0x00;
  202.  
  203.    enable_interrupts(INT_RDA); //HAbilita interrupcion por puerto serial
  204.    enable_interrupts(GLOBAL);  // Habilita las interrupcciones globales
  205.  
  206.    s=80;
  207.  
  208.  
  209.    while(TRUE)
  210.    {
  211.     // configura # de salidas
  212.    //***********************
  213.    //num = sizeof(s4d7);
  214.    // porta=tama;
  215. // num=num -1;
  216.  // num=8;
  217.  
  218.              
  219.   //****************************                  
  220.  
  221.     //  Reset_cpu();
  222.    
  223.    
  224.     // SALIDAS TRIS //    
  225.     if (n>=7)               // selecciono las salidas que necesito para que por error no se prendan los que no necesito
  226.        SET_TRIS_a(0B00000000);
  227.         if (n==6)
  228.            SET_TRIS_a(0B10000000);
  229.                if (n==5)
  230.                SET_TRIS_a(0B11000000);
  231.                    if (n==4)
  232.                    SET_TRIS_a(0B11100000);      
  233.                       if (n==3)            
  234.                       SET_TRIS_a(0B11110000);        
  235.                         if (n<=2)
  236.                           SET_TRIS_a(0B11111000);              
  237.  
  238.    //*********************************
  239.  
  240.    if (!input_state(acc))
  241.       {
  242.       ret1();
  243.       flag2=0;
  244.       }
  245.    if ((input_state(acc))&&(flag2==0))
  246.     {
  247.       flag2=1;
  248.       puerto=0;
  249.       secuencia3();
  250.       secuencia3();
  251.     }
  252.  
  253.  
  254.  
  255.  
  256.    // VALOR INTERUPCION /
  257.    if (flag==1)
  258.       {
  259.  
  260.        putc(guardar);
  261.         switch(valor)// aqui se piede el contenido sde valor
  262.          {  
  263.          case 'a':  
  264.            // putc('m');
  265.         // guardar=valor;  
  266.          puerto=0;
  267.          secuencia1();                  
  268.          break;  
  269.          case 'b':  
  270.          guardar=valor;
  271.          secuencia2();
  272.          break;
  273.          case 'c':
  274.          guardar=valor;
  275.          secuencia3();
  276.          break;
  277.          case 'd':
  278.          guardar=valor;
  279.          secuencia4();
  280.          break;
  281.          case 'e':  
  282.          guardar=valor;
  283.          secuencia5();                  
  284.          break;  
  285.          case 'f':
  286.          guardar=valor;
  287.          secuencia6();
  288.          break;
  289.          case 'g':
  290.          guardar=valor;
  291.          secuencia7();
  292.          break;
  293.          case 'h':
  294.          guardar=valor;
  295.          secuencia8();
  296.          break;
  297.          case 'i':
  298.          guardar=valor;
  299.          secuencia9();
  300.          break;
  301.          case 'j':
  302.          guardar=valor;
  303.          secuencia10();
  304.          break;
  305.          case 'k':
  306.          guardar=valor;
  307.          secuencia11();
  308.          break;
  309.          
  310.          // EEPROM //
  311.          case 't': // DIRECCIONALES
  312.          write_eeprom(0,guardar);
  313.          case 'u': // pwmh
  314.          write_eeprom(0,guardar);
  315.          case 'v': // pwml
  316.          write_eeprom(0,guardar);
  317.          break;
  318.          case 'w': // ESTACIONARIAS
  319.          write_eeprom(1,guardar);
  320.          break;
  321.          case 'x': // FRENO
  322.          write_eeprom(2,guardar);
  323.          break;
  324.          case 'y': // MEDIAS
  325.          write_eeprom(3,guardar);
  326.          break;
  327.          case 'z': // SALUDO
  328.          write_eeprom(4,guardar);
  329.          break;
  330.          // default:
  331.          }  
  332.     mezcla=0x00;// LIMPIO EL PUERTO LUEGO DE VISUALIZAR LA FUNCION QUE QUIERO
  333.     salida();
  334.     flag=0;
  335.     valor=0;
  336.      // guardar =valor;
  337.     }
  338.  /* if (input_state(der))
  339.     {
  340.     putc(guardar);
  341.     valor=read_eeprom(0);
  342.     flag=1;
  343.    
  344.     }
  345.    
  346.  */      
  347.  
  348.     // DISRIMINA EL ESTADO STOP DIRECIONALES O MEDIAS //
  349.     //************************************************//
  350.     // puerto==0  solo las 2 direccionales1  
  351.     // puerto==1  stop izquierodo y direccional derecha
  352.     // puerto==2  stop derecho y direccional izquierda
  353.     // puerto==3  solo direccional derecha
  354.     // puerto==4  solo direccional izquierda
  355.     if ((!input_state(stop))&&(!input_state(izq))&&(!input_state(der))&&(!input_state(medias)))// todo apagado
  356.     {
  357.     porta=0x00;
  358.     portb=0x00;
  359.  
  360.     }
  361.        if ((input_state(stop))&&(!input_state(izq))&&(!input_state(der))&&(!input_state(medias)))// solo freno
  362.        {
  363.        //puerto=0;
  364.        frenoflash();
  365.        }
  366.        if ((input_state(stop))&&(input_state(izq))&&(input_state(der))&&(!input_state(medias)))// ambas direccionales activas
  367.        {
  368.        puerto=0;
  369.        secuencia1();
  370.    
  371.        }
  372.           if ((input_state(stop))&&(!input_state(izq))&&(input_state(der))&&(!input_state(medias)))//freno izquierdo activo - direccional derecha activa
  373.           {
  374.           puerto=1;
  375.           secuencia1();
  376.  
  377.           }
  378.              if ((input_state(stop))&&(input_state(izq))&&(!input_state(der))&&(!input_state(medias))) // freno derecho activo - direccional izquierda activa
  379.              {
  380.               puerto =2;
  381.               secuencia1();
  382.  
  383.              }
  384.                 if ((!input_state(stop))&&(input_state(izq))&&(input_state(der))&&(!input_state(medias))) //ambas direccionales estacionarias
  385.                 {
  386.                 puerto=0;
  387.                 secuencia1();
  388.  
  389.                 }
  390.                    if ((!input_state(stop))&&(!input_state(izq))&&(input_state(der))&&(!input_state(medias)))//solo direccional derecha activa
  391.                    {
  392.                    puerto=3;
  393.                    secuencia1();
  394.                    }                    
  395.                       if  ((!input_state(stop))&&(input_state(izq))&&(!input_state(der))&&(!input_state(medias)))//solo direccional izquierda activa
  396.                       {
  397.                       puerto=4;
  398.                        secuencia1();
  399.                       }                    
  400.                          if ((!input_state(stop))&&(!input_state(izq))&&(!input_state(der))&&(input_state(medias)))//solo medias
  401.                          {
  402.                          puerto=0;
  403.                          secuencia10();// medias solo
  404.                          }
  405.                             if ((!input_state(stop))&&(input_state(izq))&&(input_state(der))&&(input_state(medias)))//solo direccionales estacionarias
  406.                             {
  407.                             puerto =0;
  408.                             secuencia1();
  409.                             }
  410.                                if ((!input_state(stop))&&(!input_state(izq))&&(input_state(der))&&(input_state(medias))) //media izquierda activa dirrecional derecha activa
  411.                                {
  412.                                puerto=1;
  413.                                 secuencia1();
  414.                                }  
  415.                                   if ((!input_state(stop))&&(input_state(izq))&&(!input_state(der))&&(input_state(medias)))// media derecha activa direccional izquierda aciva
  416.                                   {
  417.                                   puerto=2;
  418.                                   secuencia1();
  419.                                   }
  420.                                       if ((input_state(stop))&&(input_state(izq))&&(input_state(der))&&(input_state(medias)))// todo activado da solo direccionals
  421.                                      {
  422.                                      puerto =0;
  423.                                      secuencia1();
  424.                                      }
  425.                                         if ((input_state(stop))&&(!input_state(izq))&&(!input_state(der))&&(input_state(medias)))// todo activado da solo direccionals
  426.                                         {
  427.                                         frenoflash();
  428.                                         }
  429.  
  430.      
  431.  
  432.      
  433.    }
  434.    }
  435.  
  436.  
  437.  
  438.      
  439.      
  440.      
  441.      
  442.      
  443.          void dimmer()
  444.     {        
  445.                     // reinicio temporizador al hacer un cambio
  446.      if (intensidad==0)     // si variable en 1 prendo primer segmento
  447.     {
  448.     //intensidad=-1;
  449.  
  450.      porta=0;
  451.      delay_ms(300);
  452.   //  tenue();
  453.  
  454.     }
  455.    intensidad++;           // le sumo 1 a k
  456.     if (intensidad>5)      // si pasa de 7 vuevo a 0
  457.     {
  458.     intensidad=0;         // reinicio a 1
  459.     }
  460.  
  461.  
  462.    
  463.      if (intensidad==1)     // si variable en 1 prendo primer segmento
  464.     {
  465.     //intensidad=-1;
  466.  
  467.   // pwmh=0;                 //
  468.    //pwml=255;
  469.    pwmh=0;                 //
  470.    pwml=1000;
  471.   //  tenue();
  472.  
  473.     }
  474.    
  475.      if (intensidad==2)     //
  476.     {
  477.  
  478.     //pwmh=50;                 //
  479.   //  pwml=200;
  480.     pwmh=250;                 //
  481.     pwml=750;
  482.      // tenue();
  483.  
  484.     }
  485.      if (intensidad==3)     //
  486.     {
  487.  
  488.    // pwmh=70;                 //
  489.    // pwml=180;
  490.    
  491.     pwmh=500;                 //
  492.     pwml=500;
  493.     //  tenue();
  494.  
  495.     }
  496.      if (intensidad==4)     //
  497.     {
  498.  
  499.    // pwmh=100;                 //
  500.    // pwml=150;
  501.     pwmh=750;                 //
  502.     pwml=250;
  503.     //  tenue();
  504.  
  505.     }
  506.      if (intensidad==5)     //
  507.     {
  508.  
  509.    // pwmh=150;                 //
  510.    // pwml=100;
  511.       pwmh=1000;                 //
  512.       pwml=0;
  513.       intensidad=0;
  514.     //  tenue();
  515.  
  516.     }  
  517.      if (intensidad==6)     //
  518.     {
  519.  
  520.   //  pwmh=200;                 //
  521.   //  pwml=50;
  522.     pwmh=800;                 //
  523.     pwml=200;
  524.     //  tenue();
  525.  
  526.     }
  527.      if (intensidad==7)     //
  528.     {
  529.  
  530.  //  pwmh=255;                 //
  531.   // pwml=0;
  532.      pwmh=1000;                 //
  533.      pwml=0;
  534.    intensidad=0;
  535.      // tenue();
  536.  
  537.  
  538.     }    
  539.    
  540.     //delay_ms(20);
  541.   // WRITE_EEPROM(1,pwmh); // grabo en eeprom  
  542.   // WRITE_EEPROM(2,pwmb); // grabo en eeprom
  543.     }
  544.      // ****** fin del for del dimmer
  545.      
  546.      
  547.      
  548.        // FUNCIONES ***
  549.       //********************************************
  550.       // "FUNCION SALIDA"   define que puertos usare
  551.       void salida()
  552.       {
  553.        if (puerto==0)// puertos A y B
  554.         {
  555.         porta=mezcla;
  556.         portb=mezcla;
  557.         }    
  558.        if (puerto==1) // puerto A derecho
  559.         {
  560.          portb=0xff;;
  561.          porta=mezcla;
  562.        
  563.         }
  564.        if (puerto==2) // puerto B izquierdo
  565.         {
  566.         porta=0xff;
  567.         portb=mezcla;
  568.         }    
  569.         if (puerto==3) // puerto B izquierdo
  570.         {
  571.         portb=0x00;
  572.         porta=mezcla;
  573.         }
  574.         if (puerto==4) // puerto B izquierdo
  575.         {
  576.         porta=0x00;
  577.         portb=mezcla;
  578.         }
  579.       }
  580.      
  581.      
  582.      
  583.      
  584.      
  585.     // *****************************
  586.     // RETARDO ***
  587.     void ret1()
  588.     {
  589.         delay_ms(s);
  590.     }
  591.      // SEC1 *** uno a uno se desplaza y apaga el anterior auto fantastico (uno solo se ve encendido)
  592.     void secuencia1()
  593.     {
  594.            for(j=0;j<=n;j++)
  595.            {
  596.            bit_set(mezcla,j);
  597.            //bit_set(porta,j)   ;
  598.            //bit_set(portb,j)   ;
  599.            salida();
  600.            ret1() ;
  601.            bit_clear(mezcla,j) ;
  602.            salida();
  603.            //bit_clear(porta,j) ;
  604.            //bit_clear(portb,j) ;
  605.            }
  606.            if (doble==1)
  607.            {
  608.                for (j=n;j>=0;j--)
  609.                {
  610.                 bit_set(mezcla,j);
  611.               // bit_set(porta,j)   ;
  612.               // bit_set(portb,j)   ;
  613.               salida();
  614.                ret1() ;
  615.                 bit_clear(mezcla,j) ;
  616.                 salida();
  617.                 //bit_clear(porta,j) ;
  618.               // bit_clear(portb,j) ;
  619.                }
  620.            }
  621.     }
  622.     //************************************
  623.     //******** sec2 ********************* uno a uno se desplaza titilando y apaga el anterior (uno solo se ve encendido)
  624.     void secuencia2()
  625.     {
  626.            for(j=0;j<=n;j++)
  627.            {
  628.             for (k=0; k<=1 ; k++)
  629.               {
  630.              bit_set(mezcla,j)   ;
  631.              // bit_set(porta,j)   ;
  632.              // bit_set(portb,j)   ;
  633.              salida();
  634.               ret1() ;
  635.               //bit_clear(porta,j) ;
  636.              // bit_clear(portb,j) ;
  637.              bit_clear(mezcla,j)   ;
  638.              salida();
  639.               ret1() ;
  640.               }
  641.  
  642.            }
  643.              if (doble==1)
  644.              {
  645.               for (j=n;j>=0;j--)
  646.                 {
  647.                    for(k=0; k<=1 ; k++)
  648.                      {
  649.                      bit_set(mezcla,j)   ;
  650.                      //bit_set(porta,j)   ;
  651.                       //bit_set(portb,j)   ;
  652.                       salida();
  653.                       ret1() ;
  654.                       //bit_clear(porta,j) ;
  655.                      // bit_clear(portb,j) ;
  656.                       bit_clear(mezcla,j)   ;
  657.                       salida();
  658.                       ret1() ;
  659.                       }
  660.                 }
  661.            }
  662.     }
  663.     //************************************
  664.    
  665.    //******** sec3 ********************* uno a uno va prendiendo y va llenando
  666.     void secuencia3()
  667.     {
  668.            for(j=0;j<=n;j++)
  669.            {
  670.           bit_set(mezcla,j)   ;
  671.           //bit_set(porta,j)   ;
  672.           // bit_set(portb,j)   ;
  673.            salida();
  674.            ret1() ;
  675.            }
  676.     mezcla=0x00;
  677.     //porta=0x00;
  678.     //portb=0x00;
  679.     salida();
  680.     ret1() ;
  681.                if (doble==1)
  682.                {
  683.                   for (j=n;j>=0;j--)
  684.                       {
  685.                          //for(int8 k=0 ; k<1 ; k++)
  686.                            //{
  687.                            bit_set(mezcla,j)   ;
  688.                            // bit_set(porta,j)   ;
  689.                            // bit_set(portb,j)   ;
  690.                             salida();
  691.                             ret1() ;
  692.                            // bit_clear(porta,j) ;
  693.                             //ret1() ;
  694.                           // }
  695.                          // porta=0x00;
  696.                      }
  697.    mezcla=0x00;
  698.    //porta=0x00;
  699.    //portb=0x00;
  700.    salida();
  701.    ret1() ;
  702.                }  
  703.     }
  704.    //************************************
  705.      
  706.     //******** sec4 ********************* prende todos y los apaga todos uno a uno
  707.     void secuencia4()
  708.     {
  709.  
  710.     mezcla=0xff;
  711.     salida();
  712.    //porta=0xff;
  713.     //portb=0xff;
  714.     ret1() ;
  715.            for(j=0;j<=n;j++)
  716.            {
  717.             bit_clear(mezcla,j)   ;
  718.            // bit_clear(porta,j)   ;
  719.           // bit_clear(portb,j)   ;
  720.            salida();
  721.            ret1() ;
  722.            }
  723.  
  724.                if (doble==1)
  725.                {
  726.               // porta=0xff;
  727.               // portb=0xff;
  728.                  mezcla=0xff;
  729.                salida();
  730.                ret1() ;
  731.                   for (j=n;j>=0;j--)
  732.                       {
  733.                         bit_clear(mezcla,j)   ;
  734.                       // bit_clear(porta,j)   ;
  735.                       // bit_clear(portb,j)   ;
  736.                       salida();
  737.                        ret1() ;
  738.  
  739.                       }
  740.  
  741.                }  
  742.     }
  743.     //************************************
  744.      
  745.        //******** sec5 ******prende todos apaga uno a uno dejando el anterior encendido, solo uno se ve apagado
  746.     void secuencia5()
  747.     {
  748.     mezcla=0xff;
  749.     //porta=0xff;
  750.     //portb=0xff;
  751.     salida();
  752.     ret1() ;
  753.            for(j=0;j<=n;j++)
  754.            {
  755.            bit_clear(mezcla,j)   ;
  756.           // bit_clear(porta,j)   ;
  757.           // bit_clear(portb,j)   ;
  758.           salida();
  759.            ret1() ;
  760.            bit_set(mezcla,j)   ;
  761.            //bit_set(porta,j)   ;
  762.           // bit_set(portb,j)   ;
  763.           salida();
  764.            ret1() ;
  765.            }
  766.                if (doble==1)
  767.                {
  768.                mezcla=0x00;
  769.               // porta=0x00;
  770.                //portb=0x00;
  771.                salida();
  772.                ret1() ;
  773.                mezcla=0xff;
  774.                //porta=0xff;
  775.                //portb=0xff;
  776.                salida();
  777.                ret1() ;
  778.                   for (j=n;j>=0;j--)
  779.                       {
  780.               bit_clear(mezcla,j)   ;
  781.               //bit_clear(porta,j)   ;
  782.               //bit_clear(portb,j)   ;
  783.                salida();
  784.                ret1() ;
  785.                bit_set(mezcla,j)   ;
  786.                //bit_set(porta,j)   ;
  787.                //bit_set(portb,j)   ;
  788.                 salida();
  789.                ret1() ;
  790.  
  791.                       }
  792.                }      
  793.     mezcla=0x00;
  794.     //porta=0x00;
  795.     //portb=0x00;
  796.     salida();
  797.     ret1() ;      
  798.     }
  799.     //************************************  
  800.      
  801.              //******** sec6    *****//prende uno apaga,prende uno y 2 apaga, prende 1,2 y 3 apaga, va prendiendo de a uno luego prende el siguiente y estirandose
  802.     void secuencia6()
  803.     {
  804.        for(i=0;i<=n;i++)
  805.         {
  806.             for (j=0;j<=i;j++)
  807.               {
  808.               bit_set(mezcla,j)   ;
  809.               //bit_set(porta,j)   ;
  810.               //bit_set(portb,j)   ;
  811.               salida();
  812.               ret1() ;
  813.               }    
  814.          mezcla=0x00;
  815.          //porta=0x00;
  816.          //portb=0x00;
  817.          salida();
  818.          ret1() ;
  819.         }
  820.  
  821.           if (doble==1)
  822.           {
  823.             for(i=n;i>=0;i--)
  824.                {
  825.                   for (j=n;j>=i;j--)
  826.                   {
  827.                   bit_set(mezcla,j)   ;
  828.                  // bit_set(porta,j)   ;
  829.                   //bit_set(portb,j)   ;
  830.                   salida();
  831.                   ret1() ;      
  832.                   }        
  833.                mezcla=0x00;
  834.                //porta=0x00;
  835.                //portb=0x00;
  836.                salida();
  837.        
  838.                ret1() ;
  839.                }
  840.           }  
  841.     }
  842.     //************************************  
  843.     //******** sec7      prende todos luego prende todos y apaga el primero, se va encogiendo hasta apagarlos todos
  844.     void secuencia7()
  845.     {
  846.           for(i=0;i<=n;i++)
  847.           {
  848.             for (j=i;j<=n;j++)
  849.               {
  850.                bit_set(mezcla,j)   ;
  851.                //bit_set(porta,j)   ;
  852.               //bit_set(portb,j)   ;
  853.               salida();
  854.               ret1() ;
  855.               }    
  856.               mezcla=0x00;
  857.               //porta=0x00;
  858.              // portb=0x00;
  859.               salida();
  860.               ret1() ;
  861.           }
  862.           if (doble==1)
  863.           {      
  864.                for(i=n;i>=0;i--)
  865.                  {          
  866.                      for (j=i;j>=0;j--)
  867.                        {
  868.                        bit_set(mezcla,j)   ;
  869.                        //bit_set(porta,j)   ;
  870.                        //bit_set(portb,j)   ;
  871.                        salida();
  872.                        ret1() ;
  873.                      
  874.                        }              
  875.                  mezcla=0x00;
  876.                  //porta=0x00;
  877.                  //portb=0x00;
  878.                  salida();
  879.                  ret1() ;
  880.                  }      
  881.           }      
  882.     }
  883.     //************************************  
  884.     //sec8    va prendiendo hasta llegar al ultimo, este lo deja encendido y arranca de nuevo hasta el penultimo (va llenando)
  885.     void secuencia8()
  886.     {
  887.             for(i=n;i>=0;i--)
  888.        {
  889.            for(j=0;j<=i;j++)
  890.           {
  891.               for(int8 k=0;k<=0;k++)              
  892.               {
  893.               bit_set(mezcla,j)   ;
  894.               //bit_set(porta,j)   ;
  895.               //bit_set(portb,j)   ;
  896.               salida();
  897.               ret1() ;              
  898.               bit_clear(mezcla,j) ;
  899.               //bit_clear(porta,j) ;
  900.               // bit_clear(portb,j) ;
  901.               salida();
  902.               ret1() ;
  903.               }
  904.           }
  905.                        
  906.        bit_set(mezcla,i) ;
  907.        //bit_set(porta,i) ;
  908.        //bit_set(portb,i) ;
  909.        salida();
  910.        ret1() ;
  911.        }
  912.        //porta=0x00;
  913.      
  914.      
  915.       if (doble==1)
  916.       {
  917.          for(i=0;i<=n;i++)
  918.          {
  919.               for(j=n;j>=i;j--)
  920.               {
  921.                  for(int8 k=0 ; k<=0 ; k++)
  922.                  {
  923.                  bit_set(mezcla,j)   ;
  924.                 // bit_set(porta,j)   ;
  925.                 // bit_set(portb,j)   ;
  926.                 salida();
  927.                  ret1() ;              
  928.                  bit_clear(mezcla,j) ;
  929.                 // bit_clear(porta,j) ;
  930.                  //bit_clear(portb,j) ;
  931.                  salida();
  932.                  ret1() ;
  933.                  }
  934.               }
  935.           bit_set(mezcla,i) ;
  936.           //bit_set(porta,i) ;
  937.           //bit_set(portb,i) ;
  938.           salida();
  939.           ret1() ;
  940.          }
  941.         //porta=0x00;
  942.  
  943.       }
  944.     }
  945.     //************************************  
  946.     //sec9 // empieza prendiendo 1 a la vez llega al tercero y prende tambien el 1 cuando este llega tambien a 3 prende de nuevo el 1( acumula 3 encendidos) y se va hasta el ultimo 1
  947.     void secuencia9()
  948.     {
  949.       /*
  950.       si n7    14  
  951.       si n=6   12
  952.       si n=5   11
  953.       si n=4   10
  954.       si n3     9      
  955.       */
  956.        if (n==7)//
  957.        m=13;
  958.          if (n==6)
  959.          m=12;
  960.            if (n==5)
  961.            m=11;
  962.              if (n==4)
  963.              m=10;
  964.                if (n==3)
  965.                m=9;
  966.                  if (n==2)
  967.                  m=8;
  968.    
  969.         for (i=0;i<=m;i++)
  970.         {
  971.         mezcla=s1d7[i];
  972.         //porta=s1d7[i];
  973.        // portb=s1d7[i];
  974.         // s=porta;
  975.         salida();
  976.         ret1();
  977.         // PORTa=(PORTa)^=s14d7[i];
  978.         }
  979.      
  980.        if (doble==1)
  981.        {
  982.            for (i=m;i>=0;i--)
  983.            {
  984.            mezcla=s1d7[i];
  985.            //porta=s1d7[i];
  986.            //portb=s1d7[i];
  987.            // s=porta;
  988.            salida();
  989.            ret1();
  990.            // PORTa=(PORTa)^=s14d7[i];  
  991.            }        
  992.        }
  993.     }
  994.     //************************************  
  995.     //sec 10  va aumentando el brillo
  996.       void secuencia10()
  997.        {
  998.        for (g=0;g<=2;g++)
  999.            {          
  1000.            pwmh=s2d7[g];
  1001.            pwml=s3d7[g];
  1002.              for (f=0;f<=1000;f++)
  1003.              {    
  1004.               mezcla=0x00;
  1005.              // porta =0x00;
  1006.              // portb =0x00;
  1007.               salida();
  1008.               delay_us(pwml);
  1009.               mezcla=0xff;
  1010.              // porta =0xff;
  1011.              // portb =0xff;
  1012.                salida();
  1013.               delay_us(pwmh);
  1014.              }
  1015.           }
  1016.          
  1017.    
  1018.         if (doble==1) // REGRESO
  1019.         {
  1020.                 for (g=0;g<=2;g++)
  1021.                {        
  1022.                 pwml=s2d7[g];
  1023.                 pwmh=s3d7[g];
  1024.      
  1025.                 for (f=0;f<=1000;f++)
  1026.                   {    
  1027.                    mezcla=0x00;
  1028.                    //porta =0x00;
  1029.                    //portb =0x00;
  1030.                    salida();
  1031.                    delay_us(pwml);
  1032.                    mezcla=0xff;
  1033.                    //porta =0xff;
  1034.                    //porta =0xff;
  1035.                    salida();
  1036.                    delay_us(pwmh);
  1037.                   }
  1038.                }
  1039.          }
  1040.            
  1041.             if (g>2)
  1042.             {
  1043.             mezcla=0x00;
  1044.             //porta=0;
  1045.             //portb=0;
  1046.             salida();//lo muestro en los puertos
  1047.             delay_ms(400);
  1048.             }
  1049.  
  1050.  
  1051.        }
  1052.       //*****************************
  1053.     //sec10 // ramdom secuencias
  1054.     void secuencia11()
  1055.     {
  1056.     secuencia1 ();
  1057.     secuencia2 ();
  1058.     secuencia3 ();
  1059.     secuencia4 ();
  1060.     secuencia5 ();
  1061.     secuencia6 ();
  1062.     secuencia7 ();
  1063.     secuencia8 ();
  1064.     secuencia9 ();
  1065.     secuencia10();
  1066.     }    
  1067.     //**** fin funciones ****
  1068.     //****************************
  1069.    
  1070.  
  1071.     void freno()
  1072.     {
  1073.  
  1074.    
  1075.    porta=0xff;
  1076.    portb=0xff;
  1077.     ret1();
  1078.     porta=0x00;
  1079.     portb=0x00;
  1080.    ret1();
  1081.     }    
  1082.       void frenoflash()
  1083.     {    
  1084.          for (i=0;i<=5;i++)
  1085.          {
  1086.           porta=0xff;
  1087.           portb=0xff;
  1088.           delay_ms(50);
  1089.           porta=0x00;
  1090.           portb=0x00;
  1091.           delay_ms(50);
  1092.          
  1093.          }
  1094.    delay_ms(400);
  1095.     }
  1096.    
  1097.     void suiche()
  1098.    {
  1099.    
  1100.  
  1101.    
  1102.    }
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 02 de Mayo de 2022, 17:55:39
Cita de: DominusDRR en 02 de Mayo de 2022, 16:00:31
Cita de: johenrod en 02 de Mayo de 2022, 15:54:34
Cita de: DominusDRR en 02 de Mayo de 2022, 15:45:23
Miré el ensamblador que genera para determinar que sucede con esa variable, o espere a alguien que simule su proyecto.
0 errors
0 warnings
build successful

Hombre, el lenguaje ensamblador que genera el código. En alguna parte debes tener una opción para desensamblar el código compilado.
que pena no sabia como hacerlo , me toco en 2 partes.
  - Tienes que ingresar para ver archivos adjuntos -  
     
 
   
 
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: DominusDRR en 02 de Mayo de 2022, 18:54:58
Cita de: johenrod en 02 de Mayo de 2022, 17:55:39
Cita de: DominusDRR en 02 de Mayo de 2022, 16:00:31
Cita de: johenrod en 02 de Mayo de 2022, 15:54:34
Cita de: DominusDRR en 02 de Mayo de 2022, 15:45:23
Miré el ensamblador que genera para determinar que sucede con esa variable, o espere a alguien que simule su proyecto.
0 errors
0 warnings
build successful

Hombre, el lenguaje ensamblador que genera el código. En alguna parte debes tener una opción para desensamblar el código compilado.
que pena no sabia como hacerlo , me toco en 2 partes.
  - Tienes que ingresar para ver archivos adjuntos -  
     
 
   
 


La parte que realiza la recolección del datos del buffer de recepción, parece correcta.

(https://pbs.twimg.com/media/FRyNLxvXIAIbuoG?format=png&name=medium)


Pero la parte que se realiza antes del switch, salta a la dirección 0x0D0 y no está tal dirección en el ensamblador.

(https://pbs.twimg.com/media/FRyNlggXoAEkUy8?format=png&name=medium)

¿Podrías quitar ese putc(guardar) y volver a compilar y generar el ensamblador para determinar que sucede?
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 02 de Mayo de 2022, 19:07:54
Citar
¿Podrías quitar ese putc(guardar) y volver a compilar y generar el ensamblador para determinar que sucede?
cordial saludo, lo que pasa es que en la tarea de buscar el error... en guardar, guarde valor para cuando entrara al switch me imprimiera lo que llegaba, lo he quitado y sigue igual, sin embargo déjame lo hago, gracias por tu esfuerzo al ayudarme.
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: DominusDRR en 02 de Mayo de 2022, 19:08:49
Cita de: johenrod en 02 de Mayo de 2022, 17:55:39
Cita de: DominusDRR en 02 de Mayo de 2022, 16:00:31
Cita de: johenrod en 02 de Mayo de 2022, 15:54:34
Cita de: DominusDRR en 02 de Mayo de 2022, 15:45:23
Miré el ensamblador que genera para determinar que sucede con esa variable, o espere a alguien que simule su proyecto.
0 errors
0 warnings
build successful

Hombre, el lenguaje ensamblador que genera el código. En alguna parte debes tener una opción para desensamblar el código compilado.
que pena no sabia como hacerlo , me toco en 2 partes.
  - Tienes que ingresar para ver archivos adjuntos -  
     
 
   
 

Pero este código que has compartido, parece que tiene más cosas que el que compartiste para simular. Tal vez por ahí hay un bug donde sin darte cuenta borras el contenido de valor antes de ejecutar el switch
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 02 de Mayo de 2022, 19:25:45
Citar
Pero este código que has compartido, parece que tiene más cosas que el que compartiste para simular. Tal vez por ahí hay un bug donde sin darte cuenta borras el contenido de valor antes de ejecutar el switch
es que al primer código solo le puse una sentencia al switch case y ahi trabaja bien pero con el programa completo ya no da.
y, valor solo lo utilizo para el switch case, estoy seguro.
  - Tienes que ingresar para ver archivos adjuntos -  
  - Tienes que ingresar para ver archivos adjuntos -  
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: KILLERJC en 02 de Mayo de 2022, 20:09:59
Cita de: DominusDRR en 02 de Mayo de 2022, 15:25:28
Me parece que volatile int valor es lo mismo que int valor
Sólo por probar a ver que pasa, sugerí: static int valor

No lo es..
volatile : Forza al compilador a volver a tomar el dato de la memoria, no asume el valor, es especial con interrupciones donde no tenes llamada entre estas funciones.
static (Dentro de una función): Hace que la el valor de la variable se mantenga al reentrar a la función, es decir que no se crea y se destruya
static (Global en un archivo): Hace que sea accesible únicamente de ese archivo.
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: DominusDRR en 02 de Mayo de 2022, 20:17:37
Cita de: johenrod en 02 de Mayo de 2022, 19:25:45
Citar
Pero este código que has compartido, parece que tiene más cosas que el que compartiste para simular. Tal vez por ahí hay un bug donde sin darte cuenta borras el contenido de valor antes de ejecutar el switch
es que al primer código solo le puse una sentencia al switch case y ahi trabaja bien pero con el programa completo ya no da.
y, valor solo lo utilizo para el switch case, estoy seguro.
  - Tienes que ingresar para ver archivos adjuntos -  
  - Tienes que ingresar para ver archivos adjuntos -

Aparentemente no hay códigos en ensamblador sin generar o erróneos.

Puede que sea un problema de hardware.

La mejor opción es depurar en código con el hardware, pero me parece que todos los que utilizan CCS recurren a simulaciones.

Si puedes depurar con el hardware, debes poner un punto de ruptura cuando se recoge el dato en la recepción serial y otro antes de ejecutar el switch para determinar si la variable valor realmente cambió con respecto al valor original.
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 05 de Mayo de 2022, 13:33:06
yo en realidad siempre lo hago con el hardware, es por eso que estoy viendo la falla en tiempo real, pero estoy loco aquí, no se si volatile no me aplique en CCS.
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: DominusDRR en 05 de Mayo de 2022, 16:43:58
Sube un video para ver pasa cuando está depurando.
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: remi04 en 07 de Mayo de 2022, 12:50:27
¿En que quedó esto?.

  ¿Has probado al poner dos putc();?,  uno dentro de la interrupción para que te devuelva el carácter recibido en valor, y otro antes del switch para ver si se conserva o te devuelve algo al azar. 

  Otra opción es usar un puntero y mirar imprimiendo en la terminal si lo que se pierde es el dato o si se está modificando la dirección de memoria.

  Probar con una struct también sería viable.

  Actualizar a la última versión del compilador por si es un bug del mismo.
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 13 de Mayo de 2022, 11:53:49
Cita de: remi04 en 07 de Mayo de 2022, 12:50:27
¿En que quedó esto?.

  ¿Has probado al poner dos putc();?,  uno dentro de la interrupción para que te devuelva el carácter recibido en valor, y otro antes del switch para ver si se conserva o te devuelve algo al azar. 

  Otra opción es usar un puntero y mirar imprimiendo en la terminal si lo que se pierde es el dato o si se está modificando la dirección de memoria.

  Probar con una struct también sería viable.

  Actualizar a la última versión del compilador por si es un bug del mismo.
Cordial saludo, he realizado tantas pruebas que no se si realice lo  que me dices y en ese orden, lo hare y comento.
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 16 de Mayo de 2022, 16:12:20
cordial saludo, logre conseguir de nuevo el pic original 16f1936 ( se habia dañado) realice las pruebas...
Citar
  ¿Has probado al poner dos putc();?,  uno dentro de la interrupción para que te devuelva el carácter recibido en valor, y otro antes del switch para ver si se conserva o te devuelve algo al azar.

  Otra opción es usar un puntero y mirar imprimiendo en la terminal si lo que se pierde es el dato o si se está modificando la dirección de memoria.

  Probar con una struct también sería viable.

  Actualizar a la última versión del compilador por si es un bug del mismo.
y dendro del switch "valor" copio este mismo a la variable guardar( esto para hacerlo en la eeprom) y ya no se esta perdiendo el dato, el problema que tengo es que la variable flag la tenia " int flag =0;" y trabaja erroneamente al hacer comparaciones en los if, si la coloco "int1" trabaja bien y si la coloco "int8 tampoco trabaja, por que puede suceder esto, se supone que en el transcurso del programa yo la estoy actualizando no deberia trabajar tambien como "int8" ?
Código: C++
  1. #define izq    pin_c0 // naranja
  2.    #define medias pin_c1 // gris
  3.    #define acc    pin_c2 // amarillo
  4.    #define der    pin_c3 // blanco
  5.    #define stop   pin_c4 // azul
  6.    
  7.   // #define speed50  delay_ms(50)
  8.    //#define speed100 delay_ms(100)
  9.   // #define speed200 delay_ms(200)
  10.  //  #define speed300 delay_ms(300)
  11.   // #define speed400 delay_ms(400)
  12.  
  13.  // #byte valor=0
  14.  
  15.   // typedef volatile char valor;
  16.  
  17.  
  18.  
  19.  
  20.      
  21.  //secuencia 9
  22.  byte const s1d7[]={0b00000001,0b00000010,0b00000100,0b00001001,0b00010010,0b00100100,0b01001001,0b10010010
  23.                     0b00100100,0b01001000,0b10010000,0b00100000,0b01000000,0b10000000,0b00000000};//0-14
  24.                          
  25.     //    byte const s2d7[]={0,50,100,150,200,255};//0-14
  26.      //   byte const s3d7[]={255,200,150,100,50,0};//0-14      
  27.        
  28.      // secuencia10
  29.      byte const s2d7[]={0,127,255};//0-14
  30.      byte const s3d7[]={255,127,0};//0-14
  31.                            
  32.      // byte const valor;        
  33.                          
  34.                
  35.                          
  36.                          
  37.    //   *******************************************************************                      
  38.  
  39.    // variables para pwm
  40.      signed int16 pwmh =0;
  41.      signed int16 pwml =0;  
  42.    //*********************
  43.  
  44.    int1  doble=0x01;         // en 0 solo ascendente en 1 asciende y regresa
  45.    signed  int8 i=0;        // variable para las secuencias  
  46.    signed  int8 j=0;       // variable para las secuencias  
  47.    signed  int8 k=0;      // variable para las secuencias  
  48.    signed  int8 m=0;     // variable para numero de salidas //  para secuencia 9
  49.    signed  int8 n=7;    // numero de salidas
  50.   // int n=num;        // numero de salidas que se van a utilizar
  51.    int8 mezcla =0;    // alberga la info del puerto para luego pasarla a los puertos a y b
  52.    signed int16 s;   // tiempo de retardo
  53.    signed int8 puerto =1;   // 0 a y b / 1 a / 2 el b elige  el puerto
  54.    //int puerto1 =1; // 0 a y b / 1 a / 2 el b elige  el puerto
  55.    signed  int16 f=0; // para secuencia10 pwm
  56.            int g=0;   // para secuencia10 pwm
  57.    signed int intensidad=0;
  58.    signed int8 valor=0;
  59.  
  60.  int1 flag=0;
  61.    int1 flag2=0;
  62.    signed int8 guardar;
  63.   // char rol=0;
  64.    
  65.  
  66.      // static int valor;
  67.    
  68.    
  69.    // declaracion funciones
  70.       void ret1        (); // retardo general secuencias
  71.       void secuencia1  ();
  72.       void secuencia2  ();
  73.       void secuencia3  ();
  74.       void secuencia4  ();    
  75.       void secuencia5  ();
  76.       void secuencia6  ();
  77.       void secuencia7  ();
  78.       void secuencia8  ();
  79.       void secuencia9  ();
  80.       void secuencia10 ();
  81.       void secuencia11 ();
  82.       void salida      (); // funcion para mostrar los efectos
  83.       void dimmer      ();
  84.       void suiche();
  85.    //*******************
  86.       void freno();
  87.       void frenoflash();
  88.  
  89.    #int_RDA
  90.    void RDA_isr(void)
  91.    {
  92.  
  93.     //valor=0;
  94.   if(kbhit())//verifico si el dato ya esta disponible
  95.  {
  96.   //valor=0;
  97.     valor=getc();//adquiero el dato
  98.  
  99.     flag=1;
  100.     puerto=0;
  101.  
  102.  }
  103.  
  104.  
  105.   //  valor=getc(); //Captura el dato recibido del PIC 1
  106.  //  guardar=getc();
  107.  // flag=1;
  108.     //guardar =valor;
  109.      //putc(valor);
  110.    
  111.      
  112.      
  113.    }
  114.    
  115.    
  116.    
  117.  
  118.  
  119.  
  120.    // EEPROM DISTRIBUCION //
  121.    /*
  122.    0 u  pwmh
  123.    1 t  pwml
  124.    2 v SECUENCIA DIRECCIONALES
  125.    3 w SECUENCIA ESTACIONARIAS
  126.    4 x SECUENCIA FRENO
  127.    5 y SECUENCIA MEDIAS
  128.    6 z SECUENCIA SALUDO
  129.  
  130.    */
  131.  
  132.  
  133.  
  134.    // VOID MAIN //
  135.    void main()
  136.    {
  137.    SET_TRIS_a(0B00000000);
  138.    SET_TRIS_b(0B00000000);
  139.    SET_TRIS_c(0B10011111);
  140.    SET_TRIS_e(0B1);
  141.    setup_adc_ports(NO_ANALOGS);
  142.    setup_comparator(NC_NC_NC_NC);
  143.    portA=0x00;
  144.    portB=0x00;
  145.    //delay_ms(4000);
  146.  
  147.    enable_interrupts(INT_RDA); //HAbilita interrupcion por puerto serial
  148.    enable_interrupts(GLOBAL);  // Habilita las interrupcciones globales
  149.  
  150.    s=80;
  151.  
  152.  
  153.    while(TRUE)
  154.    {
  155.     // configura # de salidas
  156.    //***********************
  157.    //num = sizeof(s4d7);
  158.    // porta=tama;
  159. // num=num -1;
  160.  // num=8;
  161.  
  162.              
  163.   //****************************                  
  164.  
  165.     //  Reset_cpu();
  166.    
  167.    
  168.     // SALIDAS TRIS //  
  169.     if (n>=7)               // selecciono las salidas que necesito para que por error no se prendan los que no necesito
  170.        SET_TRIS_a(0B00000000);
  171.         if (n==6)
  172.            SET_TRIS_a(0B10000000);
  173.                if (n==5)
  174.                SET_TRIS_a(0B11000000);
  175.                    if (n==4)
  176.                    SET_TRIS_a(0B11100000);      
  177.                       if (n==3)          
  178.                       SET_TRIS_a(0B11110000);        
  179.                         if (n<=2)
  180.                           SET_TRIS_a(0B11111000);              
  181.  
  182.    //*********************************
  183.  
  184.    if (!input_state(acc))
  185.       {
  186.       ret1();
  187.       flag2=0;
  188.       }
  189.    if ((input_state(acc))&&(flag2==0))
  190.     {
  191.       flag2=1;
  192.       puerto=0;
  193.       secuencia3();
  194.       secuencia3();
  195.     }
  196.  
  197.  
  198.  
  199.  
  200.    // VALOR INTERUPCION /
  201.    if (flag==1)
  202.       {
  203.         //putc(valor);
  204.        //putc(guardar);
  205.         switch(valor)// aqui se pierde el contenido de valor
  206.          {      
  207.          case 'a':  
  208.          guardar=valor;  
  209.          //puerto=0;
  210.          secuencia1();                  
  211.          break;  
  212.          case 'b':
  213.          guardar=valor;
  214.          secuencia2();
  215.          break;
  216.          case 'c':
  217.          guardar=valor;
  218.          secuencia3();
  219.          break;
  220.          case 'd':
  221.          guardar=valor;
  222.          secuencia4();
  223.          break;
  224.          case 'e':  
  225.          guardar=valor;
  226.          secuencia5();                  
  227.          break;  
  228.          case 'f':
  229.          guardar=valor;
  230.          secuencia6();
  231.          break;
  232.          case 'g':
  233.          guardar=valor;
  234.          secuencia7();
  235.          break;
  236.          case 'h':
  237.          guardar=valor;
  238.          secuencia8();
  239.          break;
  240.          case 'i':
  241.          guardar=valor;
  242.          secuencia9();
  243.          break;
  244.          case 'j':
  245.          guardar=valor;
  246.          secuencia10();
  247.          break;
  248.          case 'k':
  249.          guardar=valor;
  250.          secuencia11();
  251.          break;
  252.  
  253.          // EEPROM //
  254.          case 't': // pwmh
  255.         // write_eeprom(0,guardar);
  256.          case 'u': // pwml
  257.         // write_eeprom(1,guardar);
  258.          case 'v': //DIRECCIONALES
  259.          write_eeprom(2,guardar);
  260.          break;
  261.          case 'w': // ESTACIONARIAS
  262.          write_eeprom(3,guardar);
  263.          break;
  264.          case 'x': // FRENO
  265.         // write_eeprom(4,guardar);
  266.          break;
  267.          case 'y': // MEDIAS
  268.         // write_eeprom(5,guardar);
  269.          break;
  270.          case 'z': // SALUDO
  271.          //write_eeprom(6,guardar);
  272.          break;
  273.          // default:
  274.          }
  275.          //putc(guardar);
  276.     mezcla=0x00;// LIMPIO EL PUERTO LUEGO DE VISUALIZAR LA FUNCION QUE QUIERO
  277.     salida();
  278.     flag=0;
  279.     valor=0;
  280.      // guardar =valor;
  281.     }
  282.  /* if (input_state(der))
  283.     {
  284.     putc(guardar);
  285.     valor=read_eeprom(0);
  286.     flag=1;
  287.    
  288.     }
  289.    
  290.  */    
  291.  
  292.     // DISRIMINA EL ESTADO STOP DIRECIONALES O MEDIAS //
  293.     //************************************************//
  294.     // puerto==0  solo las 2 direccionales1
  295.     // puerto==1  stop izquierdo y direccional derecha
  296.     // puerto==2  stop derecho y direccional izquierda
  297.     // puerto==3  solo direccional derecha
  298.     // puerto==4  solo direccional izquierda
  299.     if ((!input_state(stop))&&(!input_state(izq))&&(!input_state(der))&&(!input_state(medias)))// todo apagado
  300.     {
  301.     porta=0x00;
  302.     portb=0x00;
  303.  
  304.     }
  305.        if ((input_state(stop))&&(!input_state(izq))&&(!input_state(der))&&(!input_state(medias)))// solo freno
  306.        {
  307.        puerto=0;
  308.        frenoflash();
  309.        }
  310.        if ((input_state(stop))&&(input_state(izq))&&(input_state(der))&&(!input_state(medias)))// ambas direccionales activas
  311.        {
  312.        puerto=0;
  313.        secuencia1();
  314.    
  315.        }
  316.           if ((input_state(stop))&&(!input_state(izq))&&(input_state(der))&&(!input_state(medias)))//freno izquierdo activo - direccional derecha activa
  317.           {
  318.           puerto=1;
  319.           valor=read_eeprom(3);
  320.            flag=1;
  321.  
  322.           }
  323.              if ((input_state(stop))&&(input_state(izq))&&(!input_state(der))&&(!input_state(medias))) // freno derecho activo - direccional izquierda activa
  324.              {
  325.               puerto =2;
  326.               //secuencia1();
  327.  
  328.              }
  329.                 if ((!input_state(stop))&&(input_state(izq))&&(input_state(der))&&(!input_state(medias))) //ambas direccionales estacionarias
  330.                 {
  331.                 puerto=0;
  332.                 secuencia1();
  333.  
  334.                 }
  335.                    if ((!input_state(stop))&&(!input_state(izq))&&(input_state(der))&&(!input_state(medias)))//solo direccional derecha activa
  336.                    {
  337.                    puerto=3;// solo direccional derecha
  338.                    valor=read_eeprom(3);
  339.                    flag=1;
  340.                    }                  
  341.                       if  ((!input_state(stop))&&(input_state(izq))&&(!input_state(der))&&(!input_state(medias)))//solo direccional izquierda activa
  342.                       {
  343.                       puerto=4;
  344.                        secuencia1();
  345.                       }                    
  346.                          if ((!input_state(stop))&&(!input_state(izq))&&(!input_state(der))&&(input_state(medias)))//solo medias
  347.                          {
  348.                          puerto=0;
  349.                          secuencia10();// medias solo
  350.                          }
  351.                             if ((!input_state(stop))&&(input_state(izq))&&(input_state(der))&&(input_state(medias)))//solo direccionales estacionarias
  352.                             {
  353.                             puerto =0;
  354.                             secuencia1();
  355.                             }
  356.                                if ((!input_state(stop))&&(!input_state(izq))&&(input_state(der))&&(input_state(medias))) //media izquierda activa dirrecional derecha activa
  357.                                {
  358.                                puerto=1;
  359.                                 secuencia1();
  360.                                }  
  361.                                   if ((!input_state(stop))&&(input_state(izq))&&(!input_state(der))&&(input_state(medias)))// media derecha activa direccional izquierda aciva
  362.                                   {
  363.                                   puerto=2;
  364.                                   secuencia1();
  365.                                   }
  366.                                       if ((input_state(stop))&&(input_state(izq))&&(input_state(der))&&(input_state(medias)))// todo activado da solo direccionals
  367.                                      {
  368.                                      puerto =0;
  369.                                      secuencia1();
  370.                                      }
  371.                                         if ((input_state(stop))&&(!input_state(izq))&&(!input_state(der))&&(input_state(medias)))// todo activado da solo direccionals
  372.                                         {
  373.                                         frenoflash();
  374.                                         }
  375.  
  376.      
  377.  
  378.      
  379.    }
  380.    }
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: DominusDRR en 16 de Mayo de 2022, 16:24:09
Cita de: johenrod en 16 de Mayo de 2022, 16:12:20
cordial saludo, logre conseguir de nuevo el pic original 16f1936 ( se habia dañado) realice las pruebas y dendro del switch "valor" copio este mismo a la variable guardar( esto para hacerlo en la eeprom) y ya no se esta perdiendo el dato, el problema que tengo es que la variable flag la tenia " int flag =0;" y trabaja erroneamente al hacer comparaciones en los if, si la coloco "int1" trabaja bien y si la coloco "int8 tampoco trabaja, por que puede suceder esto, se supone que en el transcurso del programa yo la estoy actualizando no deberia trabajar tambien como "int8" ?
Código: C++
  1. #define izq    pin_c0 // naranja
  2.    #define medias pin_c1 // gris
  3.    #define acc    pin_c2 // amarillo
  4.    #define der    pin_c3 // blanco
  5.    #define stop   pin_c4 // azul
  6.    
  7.   // #define speed50  delay_ms(50)
  8.    //#define speed100 delay_ms(100)
  9.   // #define speed200 delay_ms(200)
  10.  //  #define speed300 delay_ms(300)
  11.   // #define speed400 delay_ms(400)
  12.  
  13.  // #byte valor=0
  14.  
  15.   // typedef volatile char valor;
  16.  
  17.  
  18.  
  19.  
  20.      
  21.  //secuencia 9
  22.  byte const s1d7[]={0b00000001,0b00000010,0b00000100,0b00001001,0b00010010,0b00100100,0b01001001,0b10010010
  23.                     0b00100100,0b01001000,0b10010000,0b00100000,0b01000000,0b10000000,0b00000000};//0-14
  24.                          
  25.     //    byte const s2d7[]={0,50,100,150,200,255};//0-14
  26.      //   byte const s3d7[]={255,200,150,100,50,0};//0-14      
  27.        
  28.      // secuencia10
  29.      byte const s2d7[]={0,127,255};//0-14
  30.      byte const s3d7[]={255,127,0};//0-14
  31.                            
  32.      // byte const valor;        
  33.                          
  34.                
  35.                          
  36.                          
  37.    //   *******************************************************************                      
  38.  
  39.    // variables para pwm
  40.      signed int16 pwmh =0;
  41.      signed int16 pwml =0;  
  42.    //*********************
  43.  
  44.    int1  doble=0x01;         // en 0 solo ascendente en 1 asciende y regresa
  45.    signed  int8 i=0;        // variable para las secuencias  
  46.    signed  int8 j=0;       // variable para las secuencias  
  47.    signed  int8 k=0;      // variable para las secuencias  
  48.    signed  int8 m=0;     // variable para numero de salidas //  para secuencia 9
  49.    signed  int8 n=7;    // numero de salidas
  50.   // int n=num;        // numero de salidas que se van a utilizar
  51.    int8 mezcla =0;    // alberga la info del puerto para luego pasarla a los puertos a y b
  52.    signed int16 s;   // tiempo de retardo
  53.    signed int8 puerto =1;   // 0 a y b / 1 a / 2 el b elige  el puerto
  54.    //int puerto1 =1; // 0 a y b / 1 a / 2 el b elige  el puerto
  55.    signed  int16 f=0; // para secuencia10 pwm
  56.            int g=0;   // para secuencia10 pwm
  57.    signed int intensidad=0;
  58.    signed int8 valor=0;
  59.  
  60.  int1 flag=0;
  61.    int1 flag2=0;
  62.    signed int8 guardar;
  63.   // char rol=0;
  64.    
  65.  
  66.      // static int valor;
  67.    
  68.    
  69.    // declaracion funciones
  70.       void ret1        (); // retardo general secuencias
  71.       void secuencia1  ();
  72.       void secuencia2  ();
  73.       void secuencia3  ();
  74.       void secuencia4  ();    
  75.       void secuencia5  ();
  76.       void secuencia6  ();
  77.       void secuencia7  ();
  78.       void secuencia8  ();
  79.       void secuencia9  ();
  80.       void secuencia10 ();
  81.       void secuencia11 ();
  82.       void salida      (); // funcion para mostrar los efectos
  83.       void dimmer      ();
  84.       void suiche();
  85.    //*******************
  86.       void freno();
  87.       void frenoflash();
  88.  
  89.    #int_RDA
  90.    void RDA_isr(void)
  91.    {
  92.  
  93.     //valor=0;
  94.   if(kbhit())//verifico si el dato ya esta disponible
  95.  {
  96.   //valor=0;
  97.     valor=getc();//adquiero el dato
  98.  
  99.     flag=1;
  100.     puerto=0;
  101.  
  102.  }
  103.  
  104.  
  105.   //  valor=getc(); //Captura el dato recibido del PIC 1
  106.  //  guardar=getc();
  107.  // flag=1;
  108.     //guardar =valor;
  109.      //putc(valor);
  110.    
  111.      
  112.      
  113.    }
  114.    
  115.    
  116.    
  117.  
  118.  
  119.  
  120.    // EEPROM DISTRIBUCION //
  121.    /*
  122.    0 u  pwmh
  123.    1 t  pwml
  124.    2 v SECUENCIA DIRECCIONALES
  125.    3 w SECUENCIA ESTACIONARIAS
  126.    4 x SECUENCIA FRENO
  127.    5 y SECUENCIA MEDIAS
  128.    6 z SECUENCIA SALUDO
  129.  
  130.    */
  131.  
  132.  
  133.  
  134.    // VOID MAIN //
  135.    void main()
  136.    {
  137.    SET_TRIS_a(0B00000000);
  138.    SET_TRIS_b(0B00000000);
  139.    SET_TRIS_c(0B10011111);
  140.    SET_TRIS_e(0B1);
  141.    setup_adc_ports(NO_ANALOGS);
  142.    setup_comparator(NC_NC_NC_NC);
  143.    portA=0x00;
  144.    portB=0x00;
  145.    //delay_ms(4000);
  146.  
  147.    enable_interrupts(INT_RDA); //HAbilita interrupcion por puerto serial
  148.    enable_interrupts(GLOBAL);  // Habilita las interrupcciones globales
  149.  
  150.    s=80;
  151.  
  152.  
  153.    while(TRUE)
  154.    {
  155.     // configura # de salidas
  156.    //***********************
  157.    //num = sizeof(s4d7);
  158.    // porta=tama;
  159. // num=num -1;
  160.  // num=8;
  161.  
  162.              
  163.   //****************************                  
  164.  
  165.     //  Reset_cpu();
  166.    
  167.    
  168.     // SALIDAS TRIS //  
  169.     if (n>=7)               // selecciono las salidas que necesito para que por error no se prendan los que no necesito
  170.        SET_TRIS_a(0B00000000);
  171.         if (n==6)
  172.            SET_TRIS_a(0B10000000);
  173.                if (n==5)
  174.                SET_TRIS_a(0B11000000);
  175.                    if (n==4)
  176.                    SET_TRIS_a(0B11100000);      
  177.                       if (n==3)          
  178.                       SET_TRIS_a(0B11110000);        
  179.                         if (n<=2)
  180.                           SET_TRIS_a(0B11111000);              
  181.  
  182.    //*********************************
  183.  
  184.    if (!input_state(acc))
  185.       {
  186.       ret1();
  187.       flag2=0;
  188.       }
  189.    if ((input_state(acc))&&(flag2==0))
  190.     {
  191.       flag2=1;
  192.       puerto=0;
  193.       secuencia3();
  194.       secuencia3();
  195.     }
  196.  
  197.  
  198.  
  199.  
  200.    // VALOR INTERUPCION /
  201.    if (flag==1)
  202.       {
  203.         //putc(valor);
  204.        //putc(guardar);
  205.         switch(valor)// aqui se pierde el contenido de valor
  206.          {      
  207.          case 'a':  
  208.          guardar=valor;  
  209.          //puerto=0;
  210.          secuencia1();                  
  211.          break;  
  212.          case 'b':
  213.          guardar=valor;
  214.          secuencia2();
  215.          break;
  216.          case 'c':
  217.          guardar=valor;
  218.          secuencia3();
  219.          break;
  220.          case 'd':
  221.          guardar=valor;
  222.          secuencia4();
  223.          break;
  224.          case 'e':  
  225.          guardar=valor;
  226.          secuencia5();                  
  227.          break;  
  228.          case 'f':
  229.          guardar=valor;
  230.          secuencia6();
  231.          break;
  232.          case 'g':
  233.          guardar=valor;
  234.          secuencia7();
  235.          break;
  236.          case 'h':
  237.          guardar=valor;
  238.          secuencia8();
  239.          break;
  240.          case 'i':
  241.          guardar=valor;
  242.          secuencia9();
  243.          break;
  244.          case 'j':
  245.          guardar=valor;
  246.          secuencia10();
  247.          break;
  248.          case 'k':
  249.          guardar=valor;
  250.          secuencia11();
  251.          break;
  252.  
  253.          // EEPROM //
  254.          case 't': // pwmh
  255.         // write_eeprom(0,guardar);
  256.          case 'u': // pwml
  257.         // write_eeprom(1,guardar);
  258.          case 'v': //DIRECCIONALES
  259.          write_eeprom(2,guardar);
  260.          break;
  261.          case 'w': // ESTACIONARIAS
  262.          write_eeprom(3,guardar);
  263.          break;
  264.          case 'x': // FRENO
  265.         // write_eeprom(4,guardar);
  266.          break;
  267.          case 'y': // MEDIAS
  268.         // write_eeprom(5,guardar);
  269.          break;
  270.          case 'z': // SALUDO
  271.          //write_eeprom(6,guardar);
  272.          break;
  273.          // default:
  274.          }
  275.          //putc(guardar);
  276.     mezcla=0x00;// LIMPIO EL PUERTO LUEGO DE VISUALIZAR LA FUNCION QUE QUIERO
  277.     salida();
  278.     flag=0;
  279.     valor=0;
  280.      // guardar =valor;
  281.     }
  282.  /* if (input_state(der))
  283.     {
  284.     putc(guardar);
  285.     valor=read_eeprom(0);
  286.     flag=1;
  287.    
  288.     }
  289.    
  290.  */    
  291.  
  292.     // DISRIMINA EL ESTADO STOP DIRECIONALES O MEDIAS //
  293.     //************************************************//
  294.     // puerto==0  solo las 2 direccionales1
  295.     // puerto==1  stop izquierdo y direccional derecha
  296.     // puerto==2  stop derecho y direccional izquierda
  297.     // puerto==3  solo direccional derecha
  298.     // puerto==4  solo direccional izquierda
  299.     if ((!input_state(stop))&&(!input_state(izq))&&(!input_state(der))&&(!input_state(medias)))// todo apagado
  300.     {
  301.     porta=0x00;
  302.     portb=0x00;
  303.  
  304.     }
  305.        if ((input_state(stop))&&(!input_state(izq))&&(!input_state(der))&&(!input_state(medias)))// solo freno
  306.        {
  307.        puerto=0;
  308.        frenoflash();
  309.        }
  310.        if ((input_state(stop))&&(input_state(izq))&&(input_state(der))&&(!input_state(medias)))// ambas direccionales activas
  311.        {
  312.        puerto=0;
  313.        secuencia1();
  314.    
  315.        }
  316.           if ((input_state(stop))&&(!input_state(izq))&&(input_state(der))&&(!input_state(medias)))//freno izquierdo activo - direccional derecha activa
  317.           {
  318.           puerto=1;
  319.           valor=read_eeprom(3);
  320.            flag=1;
  321.  
  322.           }
  323.              if ((input_state(stop))&&(input_state(izq))&&(!input_state(der))&&(!input_state(medias))) // freno derecho activo - direccional izquierda activa
  324.              {
  325.               puerto =2;
  326.               //secuencia1();
  327.  
  328.              }
  329.                 if ((!input_state(stop))&&(input_state(izq))&&(input_state(der))&&(!input_state(medias))) //ambas direccionales estacionarias
  330.                 {
  331.                 puerto=0;
  332.                 secuencia1();
  333.  
  334.                 }
  335.                    if ((!input_state(stop))&&(!input_state(izq))&&(input_state(der))&&(!input_state(medias)))//solo direccional derecha activa
  336.                    {
  337.                    puerto=3;// solo direccional derecha
  338.                    valor=read_eeprom(3);
  339.                    flag=1;
  340.                    }                  
  341.                       if  ((!input_state(stop))&&(input_state(izq))&&(!input_state(der))&&(!input_state(medias)))//solo direccional izquierda activa
  342.                       {
  343.                       puerto=4;
  344.                        secuencia1();
  345.                       }                    
  346.                          if ((!input_state(stop))&&(!input_state(izq))&&(!input_state(der))&&(input_state(medias)))//solo medias
  347.                          {
  348.                          puerto=0;
  349.                          secuencia10();// medias solo
  350.                          }
  351.                             if ((!input_state(stop))&&(input_state(izq))&&(input_state(der))&&(input_state(medias)))//solo direccionales estacionarias
  352.                             {
  353.                             puerto =0;
  354.                             secuencia1();
  355.                             }
  356.                                if ((!input_state(stop))&&(!input_state(izq))&&(input_state(der))&&(input_state(medias))) //media izquierda activa dirrecional derecha activa
  357.                                {
  358.                                puerto=1;
  359.                                 secuencia1();
  360.                                }  
  361.                                   if ((!input_state(stop))&&(input_state(izq))&&(!input_state(der))&&(input_state(medias)))// media derecha activa direccional izquierda aciva
  362.                                   {
  363.                                   puerto=2;
  364.                                   secuencia1();
  365.                                   }
  366.                                       if ((input_state(stop))&&(input_state(izq))&&(input_state(der))&&(input_state(medias)))// todo activado da solo direccionals
  367.                                      {
  368.                                      puerto =0;
  369.                                      secuencia1();
  370.                                      }
  371.                                         if ((input_state(stop))&&(!input_state(izq))&&(!input_state(der))&&(input_state(medias)))// todo activado da solo direccionals
  372.                                         {
  373.                                         frenoflash();
  374.                                         }
  375.  
  376.      
  377.  
  378.      
  379.    }
  380.    }

¿Cómo estás trabajando el módulo RS232? ¿8 o 9 bits?

Tal vez lo que dicen en el siguiente hilo (respuesta número 7) sea el problema.

http://www.todopic.com.ar/foros/index.php?topic=15481.0 (http://www.todopic.com.ar/foros/index.php?topic=15481.0)
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 16 de Mayo de 2022, 16:54:04
Citar
¿Cómo estás trabajando el módulo RS232? ¿8 o 9 bits?

Tal vez lo que dicen en el siguiente hilo (respuesta número 7) sea el problema.
cordial saludo, el problema ya es en la bandera que no se si por extenso el codigo no funciona.
Código: C++
  1. #include <16F1936.h>
  2.    #include <stdio.h>
  3.    #include <stdlib.h>
  4.    #include <string.h>
  5.    #fuses noDEBUG   //  debug - in circuit debugger enabled on RB6 and RB7 - DISABLED
  6.    #fuses noLVP     //  LVP - low voltage enable - DISABLED
  7.    #fuses noFCMEN   //  Fail safe clock monitor - DISABLED
  8.    #fuses noIESO    //  IESO - internal / external switch over DISABLED
  9.    #fuses noBROWNOUT  //  Brown out reset selection bits - 11 BOR  DISABLED
  10.    #fuses CPD     //  CPD - date code protect DISABLED
  11.    #fuses PROTECT //  CP - code protect DISABLED
  12.    #fuses noMCLR      //  MCLRE - RE3 is MCLR
  13.    #fuses noPUT     //  PWRTE - power up timer enable bit DISABLED
  14.    #fuses noWDT    //  WDTE - watch dog enable bit - not enabled here, in code below
  15.    #fuses INTRC_IO   //  FOSC - oscillator - set to INTRC_IO-- defaults the clock to 4Mhz
  16.    #use delay(internal=8000000)
  17.  
  18.    #use rs232(baud=9600,parity=N,xmit=pin_c6,rcv=pin_c7,bits=8,errors)
  19.  
  20.    
  21.    #byte portA= 0x0C
  22.    #byte portB= 0x0D
  23.    #byte portC= 0x0E    
  24.    #byte portE= 0x10
  25.    # use fast_io(a)
  26.    # use fast_io(b)
  27.  
  28.    #define izq    pin_c0 // naranja
  29.    #define medias pin_c1 // gris
  30.    #define acc    pin_c2 // amarillo
  31.    #define der    pin_c3 // blanco
  32.    #define stop   pin_c4 // azul
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: johenrod en 16 de Mayo de 2022, 17:15:13
ya encontre el problema, al parecer no cargaba el dato en el "flag" despues de la lectura en eeprom, al parecer hay que darle un tiempo minimo, comence con 50ms y ahora con 5ms y sigue trabajando, ademas en la recepcion serial no se han vuelto a perder los datos.
cuanto serian los tiempos minimos de escritura y lectura en ccs, lo voy a buscar en el datasheet a ver que encuentro.
Código: C++
  1. if ((input_state(stop))&&(!input_state(izq))&&(input_state(der))&&(!input_state(medias)))//freno izquierdo activo - direccional derecha activa
  2.           {
  3.           puerto=0x01;
  4.           valor=read_eeprom(3);
  5.           delay_ms (5);
  6.            flag=1;
Título: Re:Se me pierde el dato recibido en una interrupción del puerto serie
Publicado por: remi04 en 16 de Mayo de 2022, 18:44:41
Cita de: johenrod en 16 de Mayo de 2022, 17:15:13
ya encontre el problema, al parecer no cargaba el dato en el "flag" despues de la lectura en eeprom, al parecer hay que darle un tiempo minimo, comence con 50ms y ahora con 5ms y sigue trabajando, ademas en la recepcion serial no se han vuelto a perder los datos.
cuanto serian los tiempos minimos de escritura y lectura en ccs, lo voy a buscar en el datasheet a ver que encuentro.
Código: C++
  1. if ((input_state(stop))&&(!input_state(izq))&&(input_state(der))&&(!input_state(medias)))//freno izquierdo activo - direccional derecha activa
  2.           {
  3.           puerto=0x01;
  4.           valor=read_eeprom(3);
  5.           delay_ms (5);
  6.            flag=1;


  El tiempo hay que dárselo entre dos o más escrituras consecutivas, no en lecturas.

 10 ms suele ser lo más usual a esperar entre cada write_eeprom(data,address); consecutivo.

En lecturas no hay que esperar nada.