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
///////////////////////////////////////////////////////////////////////////////
// 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 == 
// 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
///////////////////////////////////////////////////////////////////////////////
// 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
///////////////////////////////////////////////////////////////////////////////
// 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 == // 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
#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.
#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
