Programacion PIC

[RayLed]

Hola buen dia.
Es mi primera publicacion, en este foro aunque ya llevo tiempo checandolo, tengo un problema con respecto a una progracion que quiero realizar.

El objetivo es el siguiente, quiero hacer una acceso para cuatro puertas con un microcontrolador, lo que he logrado es hacerlo independientemente por funciones, pero no logro juntarlas y que esten disponibles al mismo tiempo, lo que me sucede es que ejecuta una funcion y asta que termina inicia la otra. Dejo el codigo espero y me ayuden.
Saludos.

#include <16F84A.h>
#fuses NOWDT,PROTECT
#use delay (clock=4000000)         //Fosc=4Mhz 
#USE standard_IO(A)
#USE standard_IO(B)
int a,b,c,d;

//////////// Primera funcion ////////
void acceso1(){  
if(input(PIN_A0)==1); {  
if (input (PIN_A0)==1){
   output_low(PIN_A1);} //// A1 led rojo
    output_low(PIN_A1); 
for(a=1;a<=5;a++){    
   output_high(PIN_A1);
   delay_ms(400);
   output_low(PIN_A1);
   delay_ms(400);}
   if(input (PIN_A0)==1){
   output_low(PIN_A1); }
   output_low(PIN_A1);
   output_high(PIN_A2);  //// A2 led verde
   delay_ms( 4000 );
    output_low(PIN_A2);
}}
////////// segunda funcion //////////////
void acceso2(){
if(input(PIN_B4)==1){  //// B4 led rojo
if (input (PIN_B4)==1){
    output_low(PIN_B5); 
}output_low(PIN_B5);
for(c=1;c<=5;c++){    
   output_high(PIN_B5);
   delay_ms(400);
   output_low(PIN_B5);
   delay_ms(400);}
if(input (PIN_B4)==1){
   output_low(PIN_B5); }
   output_low(PIN_B5);
   output_high(PIN_B6);  /// B6 led verde
   delay_ms( 4000 );
   output_low(PIN_B6);
}}
void main (void){
while(true){
output_high(PIN_A1); 
output_high(PIN_B1);
output_high(PIN_B5);
output_high(PIN_A3); 
output_low(PIN_A2);
output_low(PIN_B2);
output_low(PIN_B6);
output_low(PIN_B3);

acceso1();
acceso2();
}}} ...

 

[D@rkbytes]

El objetivo es el siguiente, quiero hacer una acceso para cuatro puertas con un microcontrolador.
Lo que he logrado es hacerlo independientemente por funciones, pero no logro juntarlas y que estén disponibles al mismo tiempo.
Lo que me sucede es que ejecuta una funcion y hasta que termina inicia la otra.

El programa del microcontrolador funciona secuencialmente porque no es multitarea.
Primero realizará la primer tarea y cuando termine pasará por orden a la siguiente.

Podrías tener más control del programa usando la interrupción por cambio de estado en el puerto B. (RB4 a RB7)
El problema es que estás usando retardos y el servicio de interrupción no responderá hasta que finalice una tarea.

Una opción sería realizar los retardos usando el TMR0 y realizar las funciones por interrupción RB4-RB7.

Si usaras otro PIC con más prestaciones como el 16F877A podrías realizar conteos de un segundo con el TMR1, tener libres los pines del puerto B para las interrupciones y sería más fácil.

Saludos.

 

[george.manson.69]

Podrias hacer por metodo de interrupciones de timer0,

Configuracion de timer 0 (100 ms)
configuracion de Timer 1 (150 ms)

Task1_timer0 (){

  process1();

}

Task2_timer1 (){

  process2();

}

main(){

while(1){

   Main_task();

}

}

Así tendrás dos tareas realizándose alternadamente en cierto tiempo y a la vez tambien estaras realizando otro proceso de main_task.

Saludos!

 

[TRILO-BYTE]

yo soy pesimo usando interrupciones del CCS bueno es que el CCS es tan poco estandar que me hace bolas

pero como dicen trabas el micro haciendo esto:

while(sentencia)
{
.....
}

for (sentencia)
{
....
}

y sobre todo asesinas con

DELAY <------es horrible programar con delays


para no meterme con interrupciones uso el delay muy chico
yo lo que hago es esto:

while(1)
{

if(segundo_aux>=5)
{
segundo_aux=0;
//hago algo
}
else
{
//hago otra cosa
}

if(minuto>=15)
{
minuto=0;
//hago algo
}
else
{
//hago otra cosa
}



delay_us(50);
inc++;

if(inc>=20)
{
mili++;
if(mili>=1000)
{
segundo++;
segundo_aux++;
if(segundo>=60)
{
minuto++;
}
}
}

}

 

[Daniel Meza]

Lo idóneo para estas cosas es usar las interrupciónes como ya te dijeron. Para tu aplicación estás de suerte que el micro 16F84 tiene una interrupción por cambio en una o más de 4 líneas.
Bastará con que discrimines cual acontecimiento ocurrió testeando el estado de los pines una vez que haya ocurrido la interrupción.
Te dejo la idea porque tampoco ando trucho en CCS

Saludos

 

[Saint_]

... hola, la programación es un arte y cada quien tiene su estilo "aunque para mi, Picasso solo hace garabatos, pero resulta que es un artista, al final cada quien con su mambo".
También coincido que seria mejor resolver el problema mediante interrupciones, aunque también se puede resolverlo en la rutina principal, pero resultaría algo complicado.
"Para que no cambie mucho el código", esta vez decidí utilizar el rtos de ccs PICC, ademas que surge como alternativa para programas con tareas distintas..."que actúa como si fuera multitarea".

#include <16F84A.h>
#fuses   NOWDT,PROTECT
#use     delay (clock=4000000)         //Fosc=4Mhz 
#use     rtos(timer=0, minor_cycle=50ms)
int        a,c;
#task(rate=400ms,max=1ms,enabled=false)
void acceso1();
#task(rate=400ms,max=1ms,enabled=false)
void acceso2();
#task(rate=50ms, max=1ms)
void test_pin_a0();
#task(rate=50ms, max=1ms)
void test_pin_b4();

void acceso1()
{
      output_low(PIN_A1); 
      for(a=1;a<=5;a++)
      {
         output_high(PIN_A1);
         rtos_yield();
         output_low(PIN_A1);
         rtos_yield();
      }
      output_high(PIN_A2);  //// A2 led verde
      for(a=1;a<=10;a++)
      {
         rtos_yield();
      }
      output_low(PIN_A2);
      output_high(PIN_A1);
      rtos_disable(acceso1);
      rtos_enable(test_pin_a0);
}
void acceso2()
{
      output_low(PIN_B5);
      for(c=1;c<=5;c++)
      {
         output_high(PIN_B5);
         rtos_yield();
         output_low(PIN_B5);
         rtos_yield();
      }
      output_high(PIN_B6);  /// B6 led verde
      for(c=1;c<=10;c++)
      {
         rtos_yield();
      }
      output_high(PIN_B5);
      output_low(PIN_B6);
      rtos_disable(acceso2);
      rtos_enable(test_pin_b4);
}
void test_pin_a0()
{
   rtos_await(input(pin_a0));
   rtos_enable (acceso1);
   rtos_disable (test_pin_a0);
}
void test_pin_b4()
{
   rtos_await(input(pin_b4));
   rtos_enable (acceso2);
   rtos_disable (test_pin_b4);
}
void main (void)
{
      output_high(PIN_A1); 
      output_low(PIN_A2);
      output_high(PIN_A3);
      output_high(PIN_B1);
      output_low(PIN_B2);
      output_low(PIN_B3);
      output_high(PIN_B5);
      output_low(PIN_B6);
      rtos_run();
}

Claro que rtos tendrá Pros y contras, pero eso que lo decidan los que lo van a utilezar.

en este link se encuentra un buen tutorial sobre el rtos de ccs picc
http://www.ucontrol.com.ar/Articulo...erativo_microcontroladores_pic_rtos.htm#intro