Asistencia en un programa

[merter]

Buenas noches, compañeros. ¿Cómo están?
Soy un novato con la programación de PIC's y he estado echándole manos a un programa que tengo.
Un generador de pulsos que me hizo un amigo, pero se fue del país.

Entonces la cosa sería saber si alguno de ustedes me pudiera ayudar con lo siguiente:
El programa consta de varias funciones, entonces al seleccionar estas funciones de un menú, se activan y comienzan a generar pulsos de una vez.
Yo quiero implementar una condición para que inicie con un pulsador e inicie la prueba y al presionarlo de nuevo, se detenga.
He buscado por Internet y sólo conseguí que se genere el pulso cuando se mantenga presionado el botón.
Bueno, aquí les pongo la función que he querido hacer funcionar con un botón:

else if ( modo==3 ){ //prueba rapida
  
  
   output_high(RELAY);         //Apago relay
   enable_interrupts(INT_TIMER1);
   enable_interrupts(INT_EXT);
   enable_interrupts(global); //Habilita interrupciones globales
   
   
  // Clear the LCD.
   printf(lcd_putc, "\f             ");
   printf(lcd_putc, "\fPrueba Rapida");
   
   
   do {
 
  
   
   printf(lcd_putc, "\n%C"0XFF); 
   output_high(PIN_PWM);       // enciende el PIN_PWM
   delay_ms( 500 );            // demora de 500 Msegundo
   printf(lcd_putc, "\n             ");
   output_low(PIN_PWM);        // apaga el PIN_PWM
   delay_ms( 100 );            // demora de 100 Msegundo
    
  

  } while (true);
}

Muchas gracias a todos aquellos que me puedan asesorar con esta función.

 

[D@rkbytes]

¿Te haz preguntado qué sucederá durante el bucle Do... While?
¿Podrá tener cambios el programa, sin instrucciones que puedan realizarlos?

Así de pronto y con lo poco que proporcionas, no puede haber mucha "asistencia" para proporcionar.

 

[merter]

Solucionado!!!

me iluminaste con esta pregunta

¿Te haz preguntado qué sucederá durante el bucle Do... While?

aqui esta la solucion

//********************************** 
else if ( modo==3 ){ //Heui rapida
  
   
  // enable_interrupts(INT_EXT);
   enable_interrupts(global); //Habilita interrupciones globales
   output_high(RELAY);         //Apago relay
  // Clear the LCD.
   printf(lcd_putc, "\fPrueba Rapida!!");

   PRI:
   do
   {
      do
      {
         do
         {            
            do
            {
               if(input(PB_START))  goto PRS;           // Con el goto salimos de todos
                printf(lcd_putc, "\nPrecione->inicio ");// los while de una vez y comenzamos la prueba
            } while(TRUE); 
         }  while(TRUE);            
      } while(TRUE);            
   } while(TRUE);
   
   PRS:                                      //Inicio de la prueba
                                           
    do 
   {      
          if(input(PB_SET))  goto PRI;
          printf(lcd_putc, "\n   Deten->Select");
          output_high(PIN_PWM);       // enciende el PIN_PWM
          delay_ms( 500 );            // demora de 500 Msegundo
          printf(lcd_putc, "\n%C"0XFF);
          output_low(PIN_PWM);        // apaga el PIN_PWM
          delay_ms( 100 );            // demora de 100 Mlsegundo
   }while(TRUE); 
}

 

[Fogonazo]

me simpatizan los bucles anidados y menos si son al por mayor.

 

[D@rkbytes]

Eso que haz escrito como solución, es bastante redundante.
Lo que debes hacer durante un bucle, es invocar rutinas o funciones.
O sea, un programa no tiene ni debe por qué tener tantos bucles anidados.
Y menos si no se justifica la causa para usarlos.

Un bucle anidado siempre debe tener una salida cuando se cumple un evento.
O sea, salir de él si un contador llega a cierto valor, o cuando una variable Boolean cambie.
Lógicamente, esas comprobaciones se realizan dentro del bucle.
Pero obviamente, al estar anidado, se deben ejecutar llamadas a funciones que nos retornen un valor.

Por ejemplo:
Realizar un retardo en lenguaje ensamblador, se hace anidando un bucle.
Se cumple una condición y se pasa al siguiente bucle.
Así será hasta que se alcance el valor esperado y se retornará.

¿Qué pasa si entras a un bucle sin algo que lo haga salir?
Por lógica, tu programa siempre se quedará ahí cuando entre en él.
Ya no hará nada más que eso, si no se impone alguna condición para salir.

Tampoco tiene caso realizar tantos bucles, si una condición basta para salir de él.
Me refiero a que un bucle basta cuando hay condiciones que cambian la trayectoria del programa.
Y en tu caso, haces bucles no necesarios para realizar esas comprobaciones.

A final de cuentas, el bucle principal del programa siempre se repetirá y dentro de él se hace todo.
Invocas rutinas, funciones, comprobaciones, y si todo va bien, continuará.
De ese no se sale y en él se debe hacer todo sin hacer uso de otro bucle.

 

[merter]

Buenas noches

bueno me elimine todos los bucles innecesarios y me quedo asi

//********************************** 
else if ( modo==3 ){ //Prueba rapida
  
   output_low(PIN_PWM);        // Verifico que comience apagado.
   enable_interrupts(global); //Habilita interrupciones globales
   lcd_gotoxy(1,1);
   printf(lcd_putc, "Prueba Rapida   ");

   PRI:
   do
   {
               if(input(PB_START))  goto PRS;           // Con el goto salimos 
                                                        // de una vez y iniciamos la prueba
                output_low(RELAY);                      //Apaga Led Start
                lcd_gotoxy(1,2);
                printf(lcd_putc, "Precione->inicio ");
                       
   } while(TRUE);
   
   PRS:{                                     //Etiqueta a donde se realiza
                                             //el salto con el goto.
      output_high(RELAY);                    //Enciende Led Start                                       
    do                                       // Hacemos parpadear al led. 
   {      
          if(input(PB_SET))  goto PRI;       //Al precionar set regresamos al inicio
          
          lcd_gotoxy(1,2);
          printf(lcd_putc, "                ");
          lcd_gotoxy(1,2);
          printf(lcd_putc, "%C  Deten->Select"0XFF);
          output_high(PIN_PWM);       // enciende el PIN_PWM
          delay_ms( 100 );            // demora de 100 Msegundo
          lcd_gotoxy(1,2);
          printf(lcd_putc, "   Deten->Select");
          output_low(PIN_PWM);        // apaga el PIN_PWM
          delay_ms( 500 );            // demora de 500 Mlsegundo
   }while(TRUE);
   
   }
}

Muchas gracias por sus consejos

 

[D@rkbytes]

Me parece que sigues sin comprender bien las cosas.
Cuando haces un bucle: while (true); jamás saldrás de él, a menos que se use una interrupción.
Y eso obviamente hará que todo lo demás esté basado en continuar por interrupciones.

A mi parecer, estás ingresando a la programación en C, sin conocer su sintaxis.
El lenguaje C es bastante potente y nos facilita de manera muy sencilla y eficaz el poder realizar programas complejos.
Pero hay que saber bien cómo funciona para que no escribamos burradas.
De hecho, C está pensado y creado para los programadores que decidieron quitarse las orejas.

 

[merter]

bueno muchachos como les dije no se mucho y despues de hacer tantas "burradas" creo que he conseguido la solucion

//**********************************
else if ( modo==2 ){ //Prueba Lenta

output_low(PIN_PWM); // Verifico que comience apagado.
enable_interrupts(global); //Habilita interrupciones globales
lcd_gotoxy(1,1);
printf(lcd_putc, "\fPrueba Lenta!!");

while(TRUE){
if(input(PB_SET))
{

output_low(RELAY); //Apaga Led Start
do
{

lcd_gotoxy(1,2);
printf(lcd_putc, "Precione->inicio ");

}while(!input(PB_START));
}

if(input(PB_START))
{
output_high(RELAY); //Enciende Led Start
do
{
lcd_gotoxy(1,2);
printf(lcd_putc, " ");
lcd_gotoxy(1,2);
printf(lcd_putc, "%C Deten->Select"0XFF);
output_high(PIN_PWM); // enciende el PIN_PWM
delay_ms( 400 ); // demora de 100 Msegundo

lcd_gotoxy(1,2);
printf(lcd_putc, " Deten->Select");
output_low(PIN_PWM); // apaga el PIN_PWM
delay_ms( 600 ); // demora de 500 Mlsegundo

}while(!input(PB_SET));
}
}
}
//**********************************


estoy seguro que he llegado a la solucion