Responder al tema

Mensaje

[QUOTE="Urbito, post: 1172199, member: 286128"]
Buenas tardes a todos. Acudo a ustedes por una pequeña ayuda.

Estoy construyendo un detector de obstáculos para invidentes.

Este mismo consta de lo siguiente:
2 bandas en las piernas(derecha e izquierda), 2 bandas en los brazos (derecha e izquierda) y una banda en el abdomen.
Las bandas de las piernas tienen 2 ultrasónicos cada una, uno lee de frente y otro inclinado.

En el caso del abdomen, tiene 3 ultrasónicos, estos leen izquierda, centro y derecha respectivamente.

Por último, las bandas de los brazos reciben una señal que les indica cómo deben prender unos motorcitos, para que vibren diferente según sea el caso.

Los casos son los siguientes:

Distancia < 50 : Vibra 250mS se apaga 83mS (Vibra 3 veces por segundo)
Distancia > 50 y < 100 : vibra 250mS y se apaga 250mS (Vibra 2 veces por segundo)
Distancia > 100 y < 200 : vibra 250mS y se apaga 750mS (Vibra 1 vez por segundo)

Distancia > 200 : Deja de vibrar.

Todo esto lo manejo de la siguiente forma:

- Tengo 5 PIC18F2550. Uno en cada banda y abdomen.

- Las piernas, hablando del caso de que no lea ningún hueco, lee la izquierda por ejemplo una distancia de frente, digamos 10mS, esto lo pasamos a uS y nos da 10.000uS, esto para dividirlo entre 58 y nos da: 172.4cm. Este valor lo divido entre 10 y me da 17.24mS.

- El valor del ECHO = 10mS lo guardo en un registro CHAR
- El valor de microsegundos = 10.000 lo guardo en un LONG
- El valor de centímetros = 172.4cm también lo guardo en un LONG, por si leo una distancia que cause que sea mayor a 255cm

- El valor de transferencia (centímetros/10) lo estoy guardando en un CHAR, esto porque estoy limitando a las piernas a que si leen un valor mayor a 250 lo desprecien y vuelvan a leer.

Teniendo todo esto claro, el valor de transferencia (centímetros/10) lo utilizo para enviar un PING directamente proporcional a su valor desde la pierna, hacia el abdomen.
El abdomen entonces recibe un PING de 17mS, este lo toma y lo multiplica por 10, y concluye que valor recibido = 170cm.

Si consideramos que los 3 sensores ultrasónicos que tiene el abdomen están leyendo valores mayores al recibido, entonces el valor recibido (170cm) es el más importante y por ende lo debemos transmitir hacia los brazos.

Cada rango que expliqué más arriba tiene un número asignado, 1 - 2 - 3 - 4.

En el caso de recibido = 170 cm, entonces asignamos a enviar el valor de 3.
Ahora enviamos un PING de 3mS a los brazos y estos deberán entonces vibrar en los términos explicados más arriba, según esta lógica.

Dicho todo esto y entendiendo un poco este funcionamiento/lógica, estoy presentando problemas en el caso de los brazos.
Estoy simulando todo en proteus, el ultrasónico de las piernas me está leyendo el valor correctamente y el controlador también está enviando el valor correctamente.
Por ende, asumo que el controlador del abdomen está recibiendo el valor correcto.

El problema está cuando envío del controlador del abdomen a los brazos, no me está trabajando correctamente.
Espero que alguien me pueda ayudar a encontrar mi error o el problema en mis códigos.
Estaría eternamente agradecido.

Esto es mi tesis de postgrado de control avanzado de procesos. Por sencillo que parezca si :( jajajaja.

- Aclaratoria 1: Todo es simulado, el medio de comunicación planteado es inalámbrico, debido a que es simulado todo, use cables y plantee que el medio inalámbrico es ideal y sin perdida o ruido alguno.

- Aclaratoria 2: Para que las piernas transmitan deben enviar un PING de 1mS (derecha) y 2mS(izquierda), también deben recibir un PING de igual magnitud para enviar el valor de distancia leído.

Aclaratoria 3: Cuando el abdomen lee el valor proveniente de las piernas, cualquiera de las 2, envía un PING DE 6mS que sera leído por ambos brazos, indicándoles a ambos que deben activarse.

Aclaratoria 4: Si los brazos reciben el PING de 6mS y no reciben valor luego de este, entonces asumen que hay un hueco.
Si es el caso de que reciben un valor (1 - 2 - 3 - 4) luego del PING de 6mS,  entonces deberá actuar según el valor que recibió.

Finalmente como les pido, asuman que una pierna está leyendo un valor y todo lo demás es despreciable.

Adjunto código de pierna izquierda, abdomen y brazo izquierdo.
Pierna derecha y brazo derecho son iguales, solo cambian los ping que envían y reciben para transmitir y recibir.

Códigos:

Pierna:
[php]///////////////////////////////////////////////////////////////////////////////
//  DESCRIPTION:  Procesos                                                   //
///////////////////////////////////////////////////////////////////////////////

Void Proceso_Recibir()
{
   if(Bandera_recibir == false)                                 // SI NO SE ESTA RECIBIENDO NINGUNA INFORMACION
   {                                                            // SE PERMITE EL ENVIO DE LA MISMA
      BANDERA_COMUNICACION = TRUE;
   }
   IF(bandera_sincronizacion2 == false)
   {
      if( bandera_recibir == True )                                // ESTE ES BASICAMENTE EL PROCESO QUE SIEMPRE SE ESTARA REALIZANDO
      {
         milis2 = 0 ;
         Do
         {
         }While(input(Recibir));                                   // CUANDO RECIBIMOS UN PING HIGH EN EL PIN RECIBIR(RB0) AQUI,
         Bandera_Recibir = False;                                  // CONTAMOS CUANTO TIEMPO DURA ENCENDIDO PARA SABER QUE DEBEMOS HACER       
      }
   }
   if(Bandera_inicio == true)
   {
      if(milis2 != 0 )                                         // SI EXISTE UN PING DIFERENTE A 1mS
      {
         BANDERA_COMUNICACION = FALSE ;
         milis2 = 0 ;
      }
   }
   if(Bandera_Alarma == True)                                // EN EL CASO DE QUE LA ALARMA AUN ESTE HABILITADA                                   
   {                                                         // ASUMIMOS QUE EL PROCESO AUN NO HA INICIADO
      if(milis2 == 8)                                        // SI RECIBIMOS UN PING DE 8mS ENTONCES PROCEDEMOS
      {                                                      // A INICIAR LA FASE 1 DE SINCRONIZACION Y
         Bandera_Sincronizacion1 = true ;                    // RESPONDEREMOS CON UN PING DE 1mS PARA INDICAR QUE
         milis2 = 0 ;                                        // EL SISTEMA DE LA PIERNA DERECHA ESTA LISTO PARA EMPEZAR
      }
      if(milis2 == 9)
      {
         Bandera_Sincronizacion2 = true ;                    // EN EL CASO DE RECIBIR UN PING DE 9mS PROCEDEMOS A EN DEFINITVA      
         milis2 = 0 ;                                        // INICIAR EL PROCESO Y APAGAR LA ALARMA
      }
   } 
}

//////////////////////////////////////////////////////////////////////////////

Void Proceso_Ultrasonico1()
{
   IF(BANDERA_INICIO == TRUE )
   {
      if(Bandera_Us1==True)
      {
         
         Output_High(Activar_Us1);
         Delay_us(15);
         Output_Low(Activar_Us1);
         milis = 0 ;
         Do
         {
         }While(Input(Receptor_EC1));
         
         echo = milis;
         milis = 0 ;
         Bandera_us1=False;
         micros = echo * 1000 ;
         cm = micros / 58 ;
         
         if(Bandera_Obstaculo == true)
         {
            if(cm<3)
            {
               Bandera_ObstaculoS = True ;
               Bandera_ObstaculoP = False ;
               Bandera_Obstaculo = False ;
               Bandera_Transmitir1 = True;
            }
            if(cm>50)
            {
               Bandera_ObstaculoS = True ;
               Bandera_ObstaculoP = False ;
               Bandera_Obstaculo = False;
               Bandera_Transmitir1 = True ;
            }
            if(cm>3 && cm<50)
            {
               Bandera_ObstaculoP = False ;
               BANDERA_Transmitir1 = False ;
               Bandera_us1 = True ;
               Bandera_Obstaculo1P = True ;
               Bandera_Obstaculo = True ;
               bandera_transmitir2 = false;
            }
         } 
         
         if(Bandera_Obstaculo1P == False)
         {
            if(cm>3 && cm<50)
            {
               Bandera_ObstaculoP = True ;
               Bandera_Transmitir1 = True ;
               Bandera_us2 = False ;
               Bandera_us1 = True ;
               bandera_transmitir2 = false;
            }
            else
            {
               Bandera_ObstaculoP = False ;
               Bandera_Obstaculo = False ;
               Bandera_ObstaculoS = False ;
               Bandera_Transmitir1 = False ;
               Bandera_Obstaculo1P = False ;
               Bandera_us1 = false ;
               Bandera_us2 = true ;
            }
         }
      }
   }
}

//////////////////////////////////////////////////////////////////////////////

Void Proceso_Ultrasonico2()
{
   IF(BANDERA_INICIO == TRUE )
   {
      if(bandera_obstaculo == false)
      {
         if(Bandera_Us2==True)
         {
            Output_High(Activar_Us2);
            Delay_us(15);
            Output_Low(Activar_Us2);
            milis = 0 ;
            Do
            {
            }While(Input(Receptor_EC2));
            echo = milis;
            milis = 0 ;
            Bandera_us2=False;
            micros = echo * 1000 ;
            cm = micros / 58 ;
            trans = cm / 10 ;
            if(cm > 250)
            {
               BANDERA_US1 = TRUE ;
               BANDERA_TRANSMITIR2 = FALSE;
            }
            IF(CM < 250)
            {
               IF(CM == TRANS)
               {
                  BANDERA_US1 = TRUE;
                  BANDERA_TRANSMITIR2 = false ;
               }
               IF(CM != TRANS)
               {
               BANDERA_TRANSMITIR2 = TRUE ;
               }
            
            }
            if(bandera_comunicacion == false)
            {
               bandera_us1 = true ;
            }
         }
      }
   }
}

//////////////////////////////////////////////////////////////////////////////

Void Proceso_Transmitir()
{
   IF(BANDERA_INICIO == TRUE )
   {
      if(Bandera_Comunicacion == TRUE)
      {
         if(Bandera_Transmitir1 == True )
         {
            if(Bandera_ObstaculoP == True )
            {
               Disable_Interrupts(int_ext);
               milis = 0 ;
               Output_High(Enviar);
               Do
               {
               }While(milis<5);
               Output_low(Enviar);
               Enable_interrupts(int_ext);
               Bandera_Transmitir1 = False ;
               Bandera_ObstaculoP = False ;
               Bandera_Us1 = True ;
               Bandera_Obstaculo = True;
               Bandera_Obstaculo1P = True;
            }
            if(Bandera_ObstaculoS == True )
            {
               Disable_Interrupts(int_ext);
               milis = 0 ;
               Output_High(Enviar);
               Do
               {
               }While(milis<5);
               Output_low(Enviar);
               Enable_interrupts(int_ext);
               Bandera_Transmitir1 = False ;
               Bandera_ObstaculoP = False ;
               Bandera_Us2 = True ;
               Bandera_Us1 = False ;
               Bandera_Obstaculo = False;
               Bandera_Obstaculo1P = False;
               Bandera_ObstaculoS = False ;               
            }
         }
         if(Bandera_Transmitir2 == True )
         {
         
            disable_interrupts(int_ext);
            output_high(enviar);
            milis=0;
            Do
            {
            }while(milis<2);
            output_low(enviar);
            milis = 0 ;
            do
            {
            }while(milis<1);
            milis=0;
            output_high(enviar);
            do
            {
            }while(milis<trans);
            output_low(enviar);
            milis=0;
            enable_interrupts(int_ext);
            bandera_transmitir2 = false ;
            BANDERA_US1 = TRUE ;
            
         }
      }
   }
}[/php]Abdomen:
[php]///////////////////////////////////////////////////////////////////////////////
//  DESCRIPTION:  Procesos                                                   //
///////////////////////////////////////////////////////////////////////////////

Void Proceso_Ultrasonicos()
{
   IF(Bandera_ultrasonicos == true)
   {
      if(Bandera_Us1==True)
      {
         Output_High(Activar_Us1);
         do
         {
         }while(milis<1);
         Output_Low(Activar_Us1);
         milis = 0 ;
         Do
         {
         }While(Input(Receptor_EC1));
         echo = milis;
         milis = 0 ;
         Bandera_us1=False;
         micros = echo * 1000 ;
         cm = micros / 58 ;
         distancia1 = cm ;
         micros = 0 ;
         milis = 0 ;
         echo = 0 ;
         Bandera_us2=true;
      }
      if(Bandera_Us2==True)
      {
         Output_High(Activar_Us2);
         do
         {
         }while(milis<1);
         Output_Low(Activar_Us2);
         milis = 0 ;
         Do
         {
         }While(Input(Receptor_EC2));
         echo = milis;
         milis = 0 ;
         Bandera_us2=False;
         micros = echo * 1000 ;
         cm = micros / 58 ;
         distancia2 = cm ;
         micros = 0 ;
         milis = 0 ;
         echo = 0 ;
         Bandera_us3=true;
      }
      if(Bandera_Us3==True)
      {
         Output_High(Activar_Us3);
         milis = 0;
         do
         {
         }while(milis<1);
         Output_Low(Activar_Us3);
         milis = 0 ;
         Do
         {
         }While(Input(Receptor_EC3));
         echo = milis;
         milis = 0 ;
         Bandera_us3=False;
         micros = echo * 1000 ;
         cm = micros / 58 ;
         distancia3 = cm ;
         micros = 0 ;
         milis = 0 ;
         echo = 0 ;
         bandera_calculo = true ;
         bandera_ultrasonicos = false ;
         bandera_us1 = true ;
      }
      
   }
}

//////////////////////////////////////////////////////////////////////////////

Void Proceso_Recibir()
{
   if(bandera_Comunicacion == true )
   {
      milis2 = 0;
      do
      {
      }while(input(recibir));
      bandera_recibir = false ;
      rec = milis2 ;
      milis2 = 0;
      bandera_responder = true ; 
     
   }
}

///////////////////////////////////////////////////////////////////////////////

Void Proceso_Actuar()
{

if(bandera_responder == true )
   {
   
      switch (rec)
      {
         case 1:
         
         Disable_interrupts(int_ext);
         output_high(enviar);
         milis = 0 ;
         Do
         {
         }While(milis<1);
         output_low(enviar);
         enable_interrupts(int_ext);
         Do
         {
            milis2=0;
         }While(bandera_Recibir==false);
         do
         {
         }while(input(recibir));
         bandera_recibir = false ;
         bandera_calculo = true ;
         bandera_responder = false ;
         r = milis2 ;
            
         break;
         
         case 2:
         
         Disable_interrupts(int_ext);
         output_high(enviar);
         milis = 0 ;
         Do
         {
         }While(milis<2);
         output_low(enviar);
         enable_interrupts(int_ext);
         Do
         {
            milis2=0;
         }While(bandera_Recibir==false);
         do
         {
         }while(input(recibir));
         bandera_recibir = false ;
         bandera_calculo = true ;
         bandera_responder = false ;
         r = milis2 ;
         
         break;
           
         case 5:
         
         if(prioridad == 0)
         {
            bandera_prioridad = true ;
            bandera_ultrasonicos = false ;
            prioridad++;
         }
         if(prioridad == 1)
         {
            bandera_prioridadd = true ;
            bandera_ultrasonicos = true ;
            prioridad = 0 ;
         }
         
         break ;
         
         default:
         
         break;
   
      }
   }
   if(bandera_prioridad == true)
   {
      Disable_interrupts(int_ext);
      output_high(enviar);
      milis = 0 ;
      Do
      {
      }While(milis<6);
      output_low(enviar);
      enable_interrupts(int_ext);
      bandera_prioridad = false ;
   }
   if(bandera_prioridadd == true)
   {
      Disable_interrupts(int_ext);
      output_high(enviar);
      milis = 0 ;
      Do
      {
      }While(milis<6);
      output_low(enviar);
      enable_interrupts(int_ext);
      bandera_prioridad = false ;
   }
   
   if(prioridad == 0)
   {
      if(bandera_Calculo == true)
      {
    
         distancia4 = r * 10 ;
         If(distancia1<distancia2)               
         {                                      
            if(Distancia1<distancia3)
            {
               if(Distancia1<Distancia4)
               {
                  comp = distancia1 ;
               }
            }
         }
         if(Distancia2<Distancia3)
         {
            if(Distancia2<Distancia4)
            {
               comp = distancia2;
            }
         }
         if(distancia3<distancia4)
         {
            comp = distancia3 ;
         }else
         {
            comp = distancia4 ;
         }
         
         if(COMP != COMP2)
         {
            if(comp < 250)
            {
               if(comp<50)
               {
      
                  act = 1 ;                     //asignamos un valor a la variable ACT para transmitirlo
                                                //cada valor asignado a un limite y cada uno de estos,
               }                                //vibra a una frecuencia diferente para diferenciarlos
               if( comp>50 && 100>comp)
               {
                  act = 2 ;     
               }
               if(comp>100 && 200<comp)
               {
                  act = 3 ;
               }
               if(comp>200)
               {
               act = 4 ;
               }
         
               BANDERA_TRANSMITIR = TRUE ;
               bandera_calculo = false ;
            }
            if(comp>250)
            {
               
               BANDERA_TRANSMITIR = TRUE ;
               bandera_calculo = false ;
               ACT = 4 ;
            }
     
         }
         IF(COMP == COMP2)
         {
            BANDERA_TRANSMITIR = FALSE ;
            BANDERA_ULTRASONICOS = TRUE ;
         }
      }
   }
   if(bandera_transmitir == true )
   {
      COMP2 = COMP;
   
      if(comp == distancia1)
      {
         
         Disable_interrupts(int_ext);
         output_high(enviar);
         milis = 0 ;
         Do
         {
         }While(milis<3);
         output_low(enviar);
         enable_interrupts(int_ext);
         milis = 0 ;
         Do
         {
         }While(milis<1);
         Disable_interrupts(int_ext);
         output_high(enviar);
         milis = 0 ;
         Do
         {
         }While(milis<act);
         output_low(enviar);
         enable_interrupts(int_ext);
         
           
      }
      if(comp == distancia2)
      {
         Disable_interrupts(int_ext);
         output_high(enviar);
         milis = 0 ;
         Do
         {
         }While(milis<6);
         output_low(enviar);
         enable_interrupts(int_ext);
         milis = 0 ;
         Do
         {
         }While(milis<1);
         Disable_interrupts(int_ext);
         output_high(enviar);
         milis = 0 ;
         Do
         {
         }While(milis<act);
         output_low(enviar);
         enable_interrupts(int_ext);
         
      }
      if(comp == distancia3)
      {
         Disable_interrupts(int_ext);
         output_high(enviar);
         milis = 0 ;
         Do
         {
         }While(milis<4);
         output_low(enviar);
         enable_interrupts(int_ext);
         milis = 0 ;
         Do
         {
         }While(milis<1);
         Disable_interrupts(int_ext);
         output_high(enviar);
         milis = 0 ;
         Do
         {
         }While(milis<act);
         output_low(enviar);
         enable_interrupts(int_ext);
         
      }
      if(comp == distancia4)
      {
         Disable_interrupts(int_ext);
         output_high(enviar);
         milis = 0 ;
         Do
         {
         }While(milis<6);
         output_low(enviar);
         enable_interrupts(int_ext);
         milis = 0 ;
         Do
         {
         }While(milis<1);
         Disable_interrupts(int_ext);
         output_high(enviar);
         milis = 0 ;
         Do
         {
         }While(milis<act);
         output_low(enviar);
         enable_interrupts(int_ext);
         
      }
      BANDERA_TRANSMITIR = FALSE ;
   }
   Bandera_ultrasonicos = true ;
}[/php]Brazo:
[php]///////////////////////////////////////////////////////////////////////////////
//  DESCRIPTION:  Procesos                                                   //
///////////////////////////////////////////////////////////////////////////////

Void Proceso_Recibir()
{
   if( bandera_recibir == True )                                // ESTE ES BASICAMENTE EL PROCESO QUE SIEMPRE SE ESTARA REALIZANDO
   {
      milis2 = 0 ;
      Do
      {
      }While(input(Recibir));                                   // CUANDO RECIBIMOS UN PING HIGH EN EL PIN RECIBIR(RB0) AQUI,
      Bandera_Recibir = False;                                  // CONTAMOS CUANTO TIEMPO DURA ENCENDIDO PARA SABER QUE DEBEMOS HACER
      proc = milis2 ;
      bandera_actuar = true ;
   }
   if(Bandera_Alarma == True)                                // EN EL CASO DE QUE LA ALARMA AUN ESTE HABILITADA                                   
   {                                                         // ASUMIMOS QUE EL PROCESO AUN NO HA INICIADO
      if(milis2 == 8)                                        // SI RECIBIMOS UN PING DE 8mS ENTONCES PROCEDEMOS
      {                                                      // A INICIAR LA FASE 1 DE SINCRONIZACION Y
         Bandera_Sincronizacion1 = true ;                    // RESPONDEREMOS CON UN PING DE 1mS PARA INDICAR QUE
         milis2 = 0 ;                                        // EL SISTEMA DE LA PIERNA DERECHA ESTA LISTO PARA EMPEZAR
      }
      if(milis2 == 9)
      {
         Bandera_Sincronizacion2 = true ;                    // EN EL CASO DE RECIBIR UN PING DE 9mS PROCEDEMOS A EN DEFINITVA      
         milis2 = 0 ;                                        // INICIAR EL PROCESO Y APAGAR LA ALARMA
      }
   } 
}

//////////////////////////////////////////////////////////////////////////////

Void Proceso_Actuar()
{
   if(bandera_actuar == true)
   {
      switch (proc)
      {
         case 4:
         
         do
         {
         milis2 = 0;
         }while(bandera_recibir == false);
         do
         {
         }while(input(recibir));
         bandera_recibir = false ;
         act = milis2;
         bandera_actuar2 = true ;
         BANDERA_ACTUAR = FALSE ;
         
         break ;
         
         case 6:
         
         milis = 0 ;
         do
         {
            milis2 = 0;
         }while(milis<1);
         
         if(bandera_recibir == false)
         {
            if(com == 0)
            {
               bandera_prioridad = true ;
               com++;
            }
            
            if(com == 1)
            {
               bandera_prioridad2 = true ;
               com = 0 ;
            }
         }
         if(bandera_recibir == true )
         {
            do
            {
            }while(input(recibir));
            bandera_recibir = false ;
            act = milis2;
            bandera_actuar3 = true ;
         }
         BANDERA_ACTUAR = FALSE ;
         
         break ;
         
         default:
         bandera_actuar = false ;
         output_low(actuador);
         break ;
      }
   }
   if(bandera_prioridad == true)
   {
      Output_high(Actuador);
      bandera_prioridad = false ;
   }
   if(bandera_prioridad2 == true)
   {
      output_low(actuador);
      bandera_prioridad2 = false ;
   }
   if(bandera_actuar2 == true)
   {
      switch (act)
      {
         case 1 :
         
         milis = 0 ;
         Output_High(Actuador);                              // SE ENCIENDE EL ACTUADOR POR 250mS
         Do
         {
         }While(milis<250);
         milis = 0 ;
         Output_Low(Actuador);                               // SE APAGA POR 83mS
         do
         {
         }While(milis<83);                                
         milis = 0;
         Output_High(Actuador);                              // SE VUELVE A ENCENDER POR 250mS
         Do
         {
         }While(milis<250);                               
         milis = 0 ;
         Output_Low(Actuador);                               // SE APAGA NUEVAMENTE POR 83mS
         do 
         {
         }While(milis<83);
         milis = 0 ;
         Output_High(Actuador);                              // SE VUELVE A ENCENDER POR 250mS                     
         Do
         {
         }While(milis<250);
         milis = 0 ;
         Output_Low(Actuador);                            // Y FINALMENTE SE APAGA POR OTROS 83mS
         do 
         {
         }While(milis<83);                                // SI NO SE HA RECIBIDO UN PING DE 10mS EN MILIS2 (RB0), SE REINICIA EL PROCESO
         milis = 0;
         
         break ;
         
         case 2 :
         
         milis = 0 ;
         Output_High(Actuador);                              // ENCENDEMOS EL ACTUADOR POR 250mS
         Do
         {
         }While(milis<250);
         milis = 0 ;
         Output_Low(Actuador);                               // LO APAGAMOS POR 250mS
         Do
         {
         }While(milis<250);
         milis = 0 ;
         Output_High(Actuador);                              // ENCENDEMOS NUEVAMENTE POR 250mS                          
         Do
         {
         }While(milis<250);
         milis = 0 ;
         Output_Low(Actuador);                               // FINALMENTE LO APAGAMOS POR 250mS
         Do
         {
         }While(milis<250);                                  // SI NO SE HA RECIBIDO UN PING DE 10mS EN MILIS2 (RB0), SE REINICIA EL PROCESO
         milis = 0 ;
         
         break ;
         
         case 3 :
         
         milis5 = 0 ;
         milis = 0 ;
         Output_high(Actuador);                              // SE ENCIENDE EL ACTUADOR POR 250mS
         Do
         {
         }While(milis<250);
         milis = 0 ;
         Output_Low(Actuador);                            // SE APAGA EL ACTUADOR POR 250mS
         milis5++;
         Do
         {
         }While(milis<250);                               
         milis = 0 ;
         milis5++ ;
         Do
         {
         }While(milis<250);                                  // PERMANECE APAGADO OTROS 250mS
         milis = 0 ; 
         milis5++ ;                           
         Do
         {
         }While(milis<250);                                  // Y FINALMENTE OTROS 250mS PARA 750mS
         milis = 0 ;                                         // SI NO SE HA RECIBIDO UN PING DE 10mS EN MILIS2 (RB0), SE REINICIA EL PROCESO
         milis5 = 0 ;
         
         break ;
         
         case 4 :
         
         output_low(actuador);
         bandera_actuar2 = false ;
         
         break ;
      }
   }
   if(bandera_actuar3 == true)
   {
      switch (act)
      {
         case 1 :
         
         milis = 0 ;
         Output_High(Actuador);                              // SE ENCIENDE EL ACTUADOR POR 250mS
         Do
         {
         }While(milis<250);
         milis = 0 ;
         Output_Low(Actuador);                               // SE APAGA POR 83mS
         do
         {
         }While(milis<83);                                
         milis = 0;
         Output_High(Actuador);                              // SE VUELVE A ENCENDER POR 250mS
         Do
         {
         }While(milis<250);                               
         milis = 0 ;
         Output_Low(Actuador);                               // SE APAGA NUEVAMENTE POR 83mS
         do 
         {
         }While(milis<83);
         milis = 0 ;
         Output_High(Actuador);                              // SE VUELVE A ENCENDER POR 250mS                     
         Do
         {
         }While(milis<250);
         milis = 0 ;
         Output_Low(Actuador);                            // Y FINALMENTE SE APAGA POR OTROS 83mS
         do 
         {
         }While(milis<83);                                // SI NO SE HA RECIBIDO UN PING DE 10mS EN MILIS2 (RB0), SE REINICIA EL PROCESO
         milis = 0;
         
         break ;
         
         case 2 :
         
         milis = 0 ;
         Output_High(Actuador);                              // ENCENDEMOS EL ACTUADOR POR 250mS
         Do
         {
         }While(milis<250);
         milis = 0 ;
         Output_Low(Actuador);                               // LO APAGAMOS POR 250mS
         Do
         {
         }While(milis<250);
         milis = 0 ;
         Output_High(Actuador);                              // ENCENDEMOS NUEVAMENTE POR 250mS                          
         Do
         {
         }While(milis<250);
         milis = 0 ;
         Output_Low(Actuador);                               // FINALMENTE LO APAGAMOS POR 250mS
         Do
         {
         }While(milis<250);                                  // SI NO SE HA RECIBIDO UN PING DE 10mS EN MILIS2 (RB0), SE REINICIA EL PROCESO
         milis = 0 ;
         
         break ;
         
         case 3 :
         
         milis5 = 0 ;
         milis = 0 ;
         Output_high(Actuador);                              // SE ENCIENDE EL ACTUADOR POR 250mS
         Do
         {
         }While(milis<250);
         milis = 0 ;
         Output_Low(Actuador);                            // SE APAGA EL ACTUADOR POR 250mS
         milis5++;
         Do
         {
         }While(milis<250);                               
         milis = 0 ;
         milis5++ ;
         Do
         {
         }While(milis<250);                                  // PERMANECE APAGADO OTROS 250mS
         milis = 0 ; 
         milis5++ ;                           
         Do
         {
         }While(milis<250);                                  // Y FINALMENTE OTROS 250mS PARA 750mS
         milis = 0 ;                                         // SI NO SE HA RECIBIDO UN PING DE 10mS EN MILIS2 (RB0), SE REINICIA EL PROCESO
         milis5 = 0 ;
         
         break ;
         
         case 4 :
         
         output_low(actuador);
         bandera_actuar3 = false ;
         
         break ;
      }
   }
}[/php]En el caso de la interrupciones:

Para medir el tiempo uso TMR1 con un oscilador de 8 Mhz interno.
Se desborda cada 1mS. Tiene asignado el valor de 63536.

y lo tengo configurado en terminos generales, de la siguiente manera:

Interrupción para el Timer 1:

[php]#int_TIMER1                                                      /////////////////////////////////////////////////////
void TIMER1_isr(void)                                            //Función de interrupción por desbordamiento TMR1  //
{                                                                /////////////////////////////////////////////////////
   if(bandera_alarma == true)                                    // Funcion para contar el tiempo
   {                                                             // para iniciar la alarma
      milis3++ ;                             
      if(milis3>100)
      {
         milis4++ ;
         milis3 = 0 ;
      }
   }
 
   if(Bandera_Recibir == True)                                   // Funcion para contar cuanto
   {                                                             // Tiempo esta en HIGH el pin RECIBIR
      milis2++;
   }
   
   milis++;                                                      // Conteo de 1mS en 1mS de uso General
   if(milis==252)
   {
      milis = 0 ;
   }
   set_timer1(Valor_TMR1);                                       // Reinicio del Timer1 antes de salir
}[/php]Para recibir información utilizo la interrupcion externa de RB0, cada vez que recibo algo, activo la bandera recibir, esto me activa el contador milis2, y con este mido la duracion de los PING.
[php]
#INT_EXT
void EXT_isr(void)
{
   BANDERA_RECIBIR = TRUE;                                       // Se enciende la bandera para indicar que el Pin Recibir esta en High
   CLEAR_INTERRUPT(INT_EXT);                                     // Se limpia la interrupcion antes de salir
   
}[/php]Anexo también:
Todo el proyecto, incluye los códigos de todos los controladores, el hex de los ultrasónicos y la simulación en proteus.

Observación:
También he usado el osciloscopio del proteus para revisar que los ultrasónicos estén enviado a los controladores los valores correctos y que los controladores estén enviando al central también el valor correcto.
Tengo dudas con el envío del controlador al brazo o cómo el brazo interpreta lo que le llega.

Espero puedan ayudarme. Agradecido cómo siempre.
[/QUOTE]

Verificación