Autor Tema: Detector de Obstaculos con Sensor Ultrasonico y PIC18f2550  (Leído 122 veces)

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

Desconectado urbito

  • PIC10
  • *
  • Mensajes: 1
Detector de Obstaculos con Sensor Ultrasonico y PIC18f2550
« en: 17 de Junio de 2017, 21:50:56 »
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 ultrasonicos cada una, uno lee de frente y otro inclinado.

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

Por ultimo las bandas de los brazos, reciben una se;al que les indica como deben prender unos motorsitos, para que vibren diferente segun 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 : viabra 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 ningun 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 centimetos = 172.4cm tambien lo guardo en un LONG, por si leo una distancia que cause que sea mayor a 255cm

-El valor de transferencia (centimetros/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 (centimetros/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 ultrasonicos que tiene el abdomen estan leyendo valores mayores al recibido, entonces el valor recibido (170cm) es el mas importante y por ende lo debemos transmitir hacia los brazos.

Cada rango que explique mas arriba tiene un numero asignado, 1 - 2 - 3 - 4.

En el caso de recibido = 170cm entonces asignamos a enviar el valor de 3. Ahora enviamos un PING de 3mS a los brazos y estos deberan entonces vibrar en los terminos explicados mas arriba segun esta logica.

Dicho todo esto y entendiendo un poco este funcionamiento/logica, estoy presentando problemas en el caso de los brazos. Estoy simulando todo en proteus, el Ultrasonico de las piernas me esta leyendo el valor correctamente y el controlador tambien esta enviando el valor correctamente. Por ende, asumo que el controlador del abdomen esta recibiendo el valor correcto.

El problema esta cuando envio del controlador del abdomen a los brazos, no me esta trabajando corretamente. Espero alguien me pueda ayudar a encontrar mi error o problema en mis codigos. Estaria eternamente agradecido.

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

-Aclaratoria1: Todo es simualdo, el medio de comunicacion planteado es inalambrico, debido a que es simulado todo, use cables y plantee que el medio inalambrico es ideal y sin perdida o ruido alguno.

-Aclaratoria2: para que las piernas transmitan deben enviar un PING de 1mS (derecha) y 2mS(izquierda), tambien deben rescibir un PING de igual magnitud para enviar el valor de distancia leido.

Aclaratoria3: cuando el abdomeen lee el valor proveniente de las piernas, cualquiera de las 2, envia un PING DE 6mS que sera leido por ambos brazos, indicandoles a ambos que deben activarse.

Aclarotoria4: 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 debera actuar segun el valor que recibio.

Finalmente como les pido, asuman que una pierna esta leyendo un valor y todo lo demas es despreciable.

Adjunto codigo de pierna izquierda, abdomen y brazo izquierdo. Pierna derecha y brazo derecho son iguales, solo cambian los ping que envian y reciben para transmitir y recibir.

Codigos:

PIERNA

Citar

///////////////////////////////////////////////////////////////////////////////
//  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 ;
           
         }
      }
   }
}




ABDOMEN


Citar

///////////////////////////////////////////////////////////////////////////////
//  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 ;
}




BRAZO


Citar

///////////////////////////////////////////////////////////////////////////////
//  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 ;
      }
   }
}





EN EL CASO DE LAS INTERRUPCIONES:

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

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

INTERRUPCION PARA TMR1
Citar

#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
}



PARA RECIBIR INFORMACION, 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.

Citar

#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
   
}




OBSERVACION:

tambien he usado el osciloscopio del proteus para revisar que los ultrasonicos esten enviado a los controladores los valores correctos y que los controladores esten enviando al c

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 5954
Re:Detector de Obstaculos con Sensor Ultrasonico y PIC18f2550
« Respuesta #1 en: 20 de Junio de 2017, 20:19:48 »
Puff que es largo y realmente todo la parte de la comunicacion, a pesar que es "simulada" es lo mas largo.
Pense que como lo explicaste, y creo entender el codigo tiene que ser MUCHO mas corto de lo que es.

Usar 5 PIC18F2550 para esto es .. una pasada. A lo sumo 1 micro central con mas potencia ( el que reciba todas las comunicaciones) Y luego un micro de lo mas simple para los sensores.
Para poder usar micros mas pequeños sin ningun problema, evitaria el tener que dividir por numeros raros y pasarlo a centimetros. Directamente me manejaria con los valores que da el sensor.

Otra cosa, si los PIC de tus brazos y piernas que lo unico que deberian hacer es tomar el valor del sensor y reenviarlo para hacerlo inalambrico. No tendrias porque estar comparando alli las distancias. Simplemente transmitirlas y que el PIC central sea quien se encargue de detectar cual es el menor y actuar en consecuencia.

Que forma de comunicacion tenes pensado hacer? No entiendo por que intentas comunicarte con una especie de ping en tiempo, el cual si o si debe poseer un tiempo especifico, esto te va a complicar luego cuando intentes comunicar. Pienso que es mas facil comunicarse de alguna forma digital y poder enviar el dato de forma digital. Si envias 1 byte o 2 no hay casi diferencia.
Ademas al ser digital permite detectar si existe o no el sensor. Podrias hacer que el PIC central haga un poll de los sensores y actuadores cada tanto, para detectar si es que alguno no responde.


Por si las dudas, que no se me entienda que haria yo es:

- Piernas : Solo envian lo recolectado, no pasado a cm, simplemente lo que da el mismo ECHO (y sin multiplicar por 1000)
- Brazos : Enviar y recibir - Envia lo recolectado de los sensores ultrasonicos y recibe por ahora el modo de vibracion.
- Central del abdomen: Recibe de los 4 sensores, si alguno no responde en el tiempo, puede activar alguna alarma indicando la falta de señal de ese punto. Recibido los 4 procede a activar las salidas arriba.

Ventajas: Control simple, ya que todo lo controla un solo punto.
Desventajas : Mas PICs, mas hardware.

Esto es "simple" de implementar excepto la comunicacion.
Pero se podria reducir mas esto a que solamente sean los Brazos y Piernas, así cada pierna se comunica con SU brazo. En ves de tener un control central cada "lado" posee su control.

Ventajas: Solo 2 programas. uno para la pierna y otro para el brazo.
Desventaja: Complicarse tal ves un poco mas con el programa, ya que se debera distinguir entre izquierda y derecha, asi poder discriminar alguna comunicacion que provenga de la otra pierna por ejemplo.

----------------------------------------------------------------------------

Consumo.... me hablas de inalambrico, pero lo inalambrico hace que tengas una bateria, y que tengas que reducir tu consumo al maximo.
Yo pensaba en esa "vibracion" y pienso que va a consumir bastante.

A mi gusto primero lo haria como te decia 4 sensores/actuadores , comunicados por cable con I2C asi te permite "direccionarlos" a cada uno. Luego si queres si entras en la parte inalambrica.


 

anything