martes, 18 de mayo de 2010

lunes, 17 de mayo de 2010

VISION POR COMPUTADORA

A continuacion se muestra una imagen y un video de la programacion de Matlab

Diagrama del circuito de control


El circuito fue en un principio diseñado con TIP41 pero el exceso de corriente generaba una buena cantidad de calor. Por lo que se opto por el uso de IGBT que resisten una potencia mayor. También para aligerar la potencia del motor se utilizo la técnica de control de PWM por lo que se diseño un circuito de que se describe en el siguiente diagrama (figura 1).


Figura 1.
El control se realiza por puerto serial desde una computadora remota y la señal sale por el puerto B de un PIC16F877A. Para controlar la salida del PWM a cada una de las bobinas del motor de pasos se utilizo una compuerta AND (74LS08). La condición para generara el paso del motor fue que el puerto B del PIC estuviera en ALTO. El PWM está en la otra compuerta de la AND, lo que mandaría un pulso de salida siempre y cuando ambos estuvieran en ALTO en ese momento. Esta señal estaría a un nivel TTL. Para desacoplar la señal y poder asegurar una buena amplitud de voltaje que llegue al Op-Amp se utilizo el opto-acoplador, cuya función también fue separa las etapas de potencia a la de control. La señal que salió del opto tenía una amplitud de 0 a 8 Volts. Esta señal llega a un Op-Amp configurado en modo inversor y sin una resistencia de retroalimentación, que sería un disparador de Schmitt. El umbral de referencia fue tomado de la línea de 16V, por medio de un divisor de voltaje de 10k y 1k ohm. Este umbral fue de 1.7 V, pasando este voltaje se hacia un dispara hasta 15 Volts al GATE del IGBT. Se pudo también observar que la operación óptima del IGBT es cuando recibe 15V.

Por cuestiones de tiempo se inicio utilizando un driver especial para IGBT, que también puede ser utilizado para MOSFETs de potencia. No se utilizaron en la composición final pues se descompletaron, pero revelaron propiedades interesantes del IGBT. Interiormente el IGBT tiene una configuración de capacitores. Estos capacitores junto con un valor específico de resistencia en la entrada del GATE nos dan el tiempo de ENCENDIDO y AMPAGADO del IGBT. El tiempo de apagado es más lento que el encendido, por lo que se utiliza un diodo en paralelo para reducir la resistencia al momento de cambiar el flujo de la corriente acumulada en la capacitancia interna del transistor.
Otro detalle es que cuando no se tiene definido en el GATE si es un O Volts o un 15 Volts en el transistor se destruye (literal explota).

Cada uno de las etapas explicadas anteriormente se repitieron 4 veces por motor, ya que se esta configurando en UNIPOLAR y cuenta con 4 Bobinas. A, A', B y B'. La secuencia es A, B, A' y B' trabajando en pasos completos.

Se tuvieron problemas con el suministro de energía, pues por una extraña razón cuando se arrancaba el control se generaba un consumo muy alto de corriente. Se soluciono parte del problemas haciendo variar la corriente de cada paso por medio del IGBT, pues las inductancias de los motores crea una resistencia al cambio de la corriente, por lo que trabajamos a una frecuencia de 4KHz. Y subió el voltaje en la bobinas. Pero aun así la corriente era demasiada que en algunas fuentes se caía el voltaje por cuestiones de protección.

VISION POR COMPUTADORA, MATLAB

el siguiente codigo que se muestra el toda la programacion en Matlab para la vision por medio de una webcam que en este caso es la Eye 312 de Genius.

%Dar de alta la camara resolucion y caracteristicas

imaqhwinfo; %informacion de las camaras detectadas(*******************NO ES NECESARIO PARA EL PROGRAMA)
vid = videoinput('winvideo',1, 'RGB24_320x240');

%Configuracion del puerto serial para la comunicacion con el micro

SerPIC = serial('COM3');
set(SerPIC,'BaudRate', 2400, 'DataBits', 8, 'Parity', 'none','StopBits', 1, 'FlowControl', 'none');
fopen(SerPIC);

%Declaracion de variables y vectores

objetos=[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0];
laser=66;
grandote=0;

%Reconocimiento de ambiente

a=getsnapshot(vid);
aa=rgb2gray(a);

%Ciclo principal en el que se correra el programa
for k = 0:0.25:7

%Obtiene imagen con cambios
b=getsnapshot(vid);
bb=rgb2gray(b);

%Diferencia entre imagen actual y el entorno aprendido
c=imsubtract(bb,aa);

%binarizacion de la imagen resultado(se calibra a las condiciones de luz)
d=c>=20;

%filtro antiruido
magic=strel('square', 2);
link=imerode(d, magic);

%Despliega foto(*************NO ES NECESARIO PARA EL PROGRAMA)
imshow(link);
hold on

%Obtener informacion de la foto
cen = regionprops(link);
num = numel(cen);

%Condicion donde se debe detectar minimo 1 objeto
if (num ~= 0)

%Identificador de objetos(se tiene que calibrar a las condiciones de luz)
for l = 1:num
if (cen(l).Area <= 47)&&(cen(l).Area >= 5)
laser = l;
end
objetos(l)=cen(l).Area;
end

%algoritmo burbuja para ordenar objetos de mas grande a mas chico
for i=1:9
for j=i+1:10
if (objetos(i) < objetos(j))
temp = objetos(i);
objetos(i) = objetos(j);
objetos(j) = temp;
end
end
end
%fin de algoritmo burbuja

%detectar el num del objeto mas grande
for z=1:num
if (cen(z).Area == objetos(1))
grandote = z;
end
end

%Condiciones para mover la pistola
if (laser == 66)
master = 100;
disp(['DISPARA']); %Despliega en la pantalla(*************NO ES NECESARIO PARA EL PROGRAMA)
else
if (objetos(1) ~= cen(laser).Area)
salidax = cen(grandote).Centroid(1) - cen(laser).Centroid(1);
saliday = cen(grandote).Centroid(2) - cen(laser).Centroid(2);
if (salidax > 0)&&(saliday > 0)
master=41; %muevete a la derecha y arriba
disp(['derecha abajo ']); %Despliega en la pantalla(*************NO ES NECESARIO PARA EL PROGRAMA)
else if (salidax < 0)&&(saliday > 0)
master = 69; %muevete izquerda y arriba
disp(['izquierda abajo ']); %Despliega en la pantalla(*************NO ES NECESARIO PARA EL PROGRAMA)
else if (salidax > 0)&&(saliday < 0)
master = 22; %muevete derecha y abajo
disp(['dereha arriba ']); %Despliega en la pantalla(*************NO ES NECESARIO PARA EL PROGRAMA)
else if (salidax < 0)&&(saliday < 0)
master = 255; %muevete izquierda y abajo
disp(['izquierda arriba ']); %Despliega en la pantalla(*************NO ES NECESARIO PARA EL PROGRAMA)
end
end
end
end
end
end
end

puppet = typecast(master, unit8);
fwrite(SerPIC, '%s', puppet); %Mandar la variable master para mover o disparar


laser=66;
end
%fin del ciclo principal del programa

fclose(SerPIC)
delete(SerPIC)
clear SerPIC

%fin de programa

codigo sentry gun,

/* con este codigo se controlan los dos motores a pasos y tambien se despliega los datos en el puerto D, los dos motores a pasos se encuentran en el puerto B, donde el nibble superior es para el motor que se mueve en Y y el nibble inferior se dejo para el motor que se mueve en X, la secuencia de pasos se despliega en el puerto D.



*/
int i;
int n;
int command;



void main() {
PORTB =0;
TRISB =0;
PORTD =0;
TRISD =0;
Usart_Init(2400);


do {

if (Usart_Data_Ready()) { // If data is received for Y axis
command = Usart_Read();
Usart_Write(command);
}
//++++++++++++++++ condiciones+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
if (command ==41){ //si es 255
i++;// derecha
n++;// arriba
}
if (command ==64){ //si es 255
i--; //izquierda
n++; // arriba
}
if (command ==22){ //si es 255
i++; // derecha
n--; // abajo
}
if (command ==255){ //si es 255
i--; // izquierda
n--; // abajo
}

if(i>7){i=0;} //resetear contador de dirrección.
if(i<0){i=7;}>
if(n>7){n=0;} //resetear contador de dirrección.
if(n<0){n=7;}

//++++++++++++++++++++++++++++++++ primer motor+++++++++++++++++++++++++++++++++++++++++++
switch (i){
case 0 : PORTB.F0 = 1;
PORTB.F1 = 0;
PORTB.F2 = 0;
PORTB.F3 = 0; break;
case 1 : PORTB.F0 = 1;
PORTB.F1 = 1;
PORTB.F2 = 0;
PORTB.F3 = 0; break;
case 2 : PORTB.F0 = 0;
PORTB.F1 = 1;
PORTB.F2 = 0;
PORTB.F3 = 0; break;
case 3 : PORTB.F0 = 0;
PORTB.F1 = 1;
PORTB.F2 = 1;
PORTB.F3 = 0; break;
case 4 : PORTB.F0 = 0;
PORTB.F1 = 0;
PORTB.F2 = 1;
PORTB.F3 = 0; break;
case 5 : PORTB.F0 = 0;
PORTB.F1 = 0;
PORTB.F2 = 1;
PORTB.F3 = 1; break;
case 6 : PORTB.F0 = 0;
PORTB.F1 = 0;
PORTB.F2 = 0;
PORTB.F3 = 1; break;
case 7 : PORTB.F0 = 1;
PORTB.F1 = 0;
PORTB.F2 = 0;
PORTB.F3 = 1; break;
default : PORTB = 0; break;
}


switch (i) {
case 0 : PORTD.F0 = 1;
PORTD.F1 = 0;
PORTD.F2 = 0;
PORTD.F3 = 0; break;

case 1 : PORTD.F0 = 1;
PORTD.F1 = 1;
PORTD.F2 = 0;
PORTD.F3 = 0; break;

case 2 : PORTD.F0 = 0;
PORTD.F1 = 1;
PORTD.F2 = 0;
PORTD.F3 = 0; break;

case 3 : PORTD.F0 = 0;
PORTD.F1 = 1;
PORTD.F2 = 1;
PORTD.F3 = 0; break;

case 4 : PORTD.F0 = 0;
PORTD.F1 = 0;
PORTD.F2 = 1;
PORTD.F3 = 0; break;

case 5 : PORTD.F0 = 0;
PORTD.F1 = 0;
PORTD.F2 = 1;
PORTD.F3 = 1; break;

case 6 : PORTD.F0 = 0;
PORTD.F1 = 0;
PORTD.F2 = 0;
PORTD.F3 = 1; break;

case 7 : PORTD.F0 = 1;
PORTD.F1 = 0;
PORTD.F2 = 0;
PORTD.F3 = 1; break;
}

//+++++++++++++++++++++++ segundo motor++++++++++++++++++++++++++++++++++++++++++++++++++++++++

switch (n){
case 0 : PORTB.F4 = 1;
PORTB.F5 = 0;
PORTB.F6 = 0;
PORTB.F7 = 0; break;

case 1 : PORTB.F4 = 1;
PORTB.F5 = 1;
PORTB.F6 = 0;
PORTB.F7 = 0; break;

case 2 : PORTB.F4 = 0;
PORTB.F5 = 1;
PORTB.F6 = 0;
PORTB.F7 = 0; break;

case 3 : PORTB.F4 = 0;
PORTB.F5 = 1;
PORTB.F6 = 1;
PORTB.F7 = 0; break;

case 4 : PORTB.F4 = 0;
PORTB.F5 = 0;
PORTB.F6 = 1;
PORTB.F7 = 0; break;

case 5 : PORTB.F4 = 0;
PORTB.F5 = 0;
PORTB.F6 = 1;
PORTB.F7 = 1; break;

case 6 : PORTB.F4 = 0;
PORTB.F5 = 0;
PORTB.F6 = 0;
PORTB.F7 = 1; break;

case 7 : PORTB.F4 = 1;
PORTB.F5 = 0;
PORTB.F6 = 0;
PORTB.F7 = 1; break;
default : PORTB = 0; break;
}


switch (n) {
case 0 : PORTD.F4 = 1;
PORTD.F5 = 0;
PORTD.F6 = 0;
PORTD.F7 = 0; break;

case 1 : PORTD.F4 = 1;
PORTD.F5 = 1;
PORTD.F6 = 0;
PORTD.F7 = 0; break;

case 2 : PORTD.F4 = 0;
PORTD.F5 = 1;
PORTD.F6 = 0;
PORTD.F7 = 0; break;

case 3 : PORTD.F4 = 0;
PORTD.F5 = 1;
PORTD.F6 = 1;
PORTD.F7 = 0; break;

case 4 : PORTD.F4 = 0;
PORTD.F5 = 0;
PORTD.F6 = 1;
PORTD.F7 = 0; break;

case 5 : PORTD.F4 = 0;
PORTD.F5 = 0;
PORTD.F6 = 1;
PORTD.F7 = 1; break;

case 6 : PORTD.F4 = 0;
PORTD.F5 = 0;
PORTD.F6 = 0;
PORTD.F7 = 1; break;

case 7 : PORTD.F4 = 1;
PORTD.F5 = 0;
PORTD.F6 = 0;
PORTD.F7 = 1; break;
}

Delay_ms(500);// delay entre cada paso


}//while
while(1);

} //~! main

viernes, 23 de abril de 2010

Programador de micros


Para programar el microcontrolador utilizamos el master-prog, el cual puedes conseguir en www.mercadolibre.com a un costo de aproximadamente 450 pesos. Y este programador viene con un CD que incluye varios compiladores y lo necesario para empezar a desarrollar aplicaciones (excepto los micros).

microcontrolador


Eh aquí el esquemático del microcontrolador pic16f877 que utilizamos para ajustar la posición de los motores a pasos. Los 4 bits menos significativos se conectan a las bobinas del motor, (el cómo movemos los motores se agregó anteriormente, hay que destacar que ese código está en C, utilizando el compilador mikroC.) el potenciometro se utiliza para sensar la posición en la que se encuentra el motor, o en este caso en que dirección apunta la pistola de paint balls.

El diseño de la base de motores (Etapa 2 de mecánica)

La construcción de las bases fue interesante por el uso de engranes. Ya que se tuvo que tomar en cuenta el Pitch de cada uno de los engranes dado que si te cierras mucho se amarran y si te abres mucho entro los centros queda muy traqueteo. La relación de engranes utilizada fue de 2.5:1 que quiere decir que por cada 2.5 vueltas del motor obtendremos una en las bases motrices. Esto ayudara a aumentar el torque y reducir la velocidad del motor.

En la creación de las piezas se utilizaron dos placas de aluminio de 3/4 in. de espesor para que quedara firme la base y en si toda la estructura. La figura siguiente muestra las dos placas antes de maquinarse y como queremos acomodarlas. En esta visión previa del proyecto se acomodaron de esta manera para tener dos grados de libertad por medio de los motores antes descritos.


Después nos topamos con la necesidad de reducir la fricción por medio del uso de baleros. Estos baleros fueron seleccionados de una base de datos de Timken por medio de su centro (3/4 in.) y que se tuvieran en existencia en el distribuidor local. Primero se pensó en baleros de rodillos cuya característica principal fuese soportar cargas verticales. Para esto se encontró el Balero de rodillos de la marca Timken T77 904A1 cuya caja se muestra en la figura. También se tomo en consideración un balero que centrara el mecanismo giratorio de nuestro robot. Para cumplir con este propósito se utilizo un balero de cono, pues su característica nos brinda soporte de carga en 2 dimensiones, entonces una centraría la base y la otra soportaría su peso. El balero utilizado fue el LM11910 con su respectiva tasa LM11949. Sus cajas se muestran a continuación también.







Después de se maquinaron los centros de las placas en un torno, aunque hubiera sido mas fácil en una fresadora. Fueron dos agujeros. El primero de 3/4 in. Para pasar el perno de soporte (un tornillo) y el segundo para posicionar el motor con su respectiva caja de ajuste. En las siguientes figuras se muestra lo antes descrito.



El ensamble final con los motores se veria desde arriba de esta manera.

AVANCE VISION

Aqui están las imágenes resultantes del código anterior:







AVANCE VISION

Aqui está el código con el que detectamos el objeto en la imagen:


Primero tomamos una imagen que se considera como fondo, luego obtenemos una nueva imagen donde ya hay un nuevo objeto (en este caso la mano) lo que representa movimiento.

Pasamos las dos imagenes a tonos de grises y las restamos, de esta manera podemos aislar el objeto nuevo, luego binarizamos la imagen para dejar en blanco el objeto y por último obtenemos el centroide del mismo para apuntar a ese punto al disparar.



CODIGO:


A = imread('foto1.jpg');
B = imread('foto2.jpg');
C=rgb2gray(A);
D=rgb2gray(B);
Z=imsubtract(C,D);
I=Z>=50;
BW = I > 0;
s = regionprops(BW, I, {'Centroid','WeightedCentroid'});
s(1).Centroid;
imshow(I)
title('PORNO CON ABEJAS');
hold on
numObj = numel(s);
for k = 1 : numObj
plot(s(k).WeightedCentroid(1), s(k).WeightedCentroid(2), 'r*');
plot(s(k).Centroid(1), s(k).Centroid(2), 'bo');
end
hold off









Funcionamiento de los motores (Etapa 1de lo mecanico)


Los motores hasta ahora se ha comprobado que si funcionan por la prueba que se hizo a 12V con un arreglo Unipolar y un arreglo de Transistores TIP41. Los diagramas se muestran a continuación y un video que avala el funcionamiento del motor.




En esta primera etapa se definió que se tiene un problema de funcionamiento, ya que el motor no da el torque suficiente, pues el TIP41 genera demasiado calor. Otro factor importante es que al querer darle mayor velocidad se pierde torque por la cuestión del tiempo que pasa cada paso generando su campo magnético. Por último se observo que el Voltaje o Potencial al que estamos sometiendo el Motor esta en el umbral inferior pues son 12V de alimentación menos la perdida de 2.5V en el TIP41( el cual es tipo Darlington). Entonces el diferencial de potencial dentro de la bobina del motor es demasiado poco para un buen desempeño.

Por tales razones hemos optado por el uso de algún switch electrónico mas potente. Por lo que al especular el mercado encontramos a los IGBT, que son una función entre las tecnologías BJT y MOSFET. Son transistores de alta velocidad, alta corriente, y alto Voltaje de polarización inversa (Vce). Para su control se utilizara un driver especial para el control de los IGBTs. Este a su vez es controlado desde un micr0-controlador protegido por Opto-acopladores. El principio del programa sigue siendo el mismo que el anterior. A continuación se muestras las piezas y sus respectivos links para obtener sus datasheets.

- Driver para IGBTs de ON Semiconductor. Parte: MC33153PG

http://www.onsemi.com/PowerSolutions/product.do?id=MC33153PG

- IGBT marca International Rectifier. Parte:IRG4PC30UPBF

https://ec.irf.com/v6/en/US/adirect/ir?cmd=catSearchFrame&domSendTo=byID&domProductQueryName=IRG4PC30UPBF

- Optoacopladores de 4 Canales marca Vishay. Parte: ILQ1

http://www.vishay.com/product?docid=82582&query=ILQ1

El micro-controlador a utilizar será el mismo de las pruebas, el 16F877A. Los datos de control se realizaran por medio de coordenadas angulares en función de la variación del voltaje a través de una resistencia variable (Pot) que será la retroalimentación que dirá que se cumplí el giro deseado en el motor. Por esta razón el micro-controlador utilizado necesita tener entradas Análogas- Digitales (ADC).


jueves, 15 de abril de 2010

Cámara Eye 312

Esta es una de las cámaras que estamos pensando utilizar, la Eye 312 marca Genius.
Equipado con un 640 x 480 (VGA) sensor CMOS, y con un botón del handy snapshot situado en la punta de la Eye 312, simplemente haga clic para tomar fotos de hasta 1.3 mega píxeles de resolución al instante.Es más, hay un micrófono incorporado - lo que significa que disfrute más clara de voz y de captura de sonido. Con los dos grandes de vídeo y audio desde el conseguir Eye 312, más cerca que nunca ha sido tan fácil.

Características principales:
  • Video de YouTube para compartir archivos
  • El micrófono integrado
  • Multi-función de limitación de la Base de Diseño
  • Giratorios de 360 grados
  • Una mayor flexibilidad de visualización

viernes, 9 de abril de 2010

Programa

El programa anterior fue programado utilizando MicroC, utilizando el puerto c del micro PIC16f877.

programa de control de posicion para motores

int adc_ref;
int adc_y;
int i;
int n;

void main() {
adc_y = 512;
i = 0;
n = 6;
PORTC = 255;
TRISC = 0;
ADCON1 = 0x80; // Configure analog inputs and Vref


Delay_ms(2000);
while(1) {
adc_ref = Adc_Read(7);// Get results of AD conversion
//Adc_Read(2); // Get results of AD conversion


if(adc_ref >= adc_y){ //comparación para ver a que lado girar

if(i>6){
i=0;}

switch (i){ //secuencia de pasos para motor
case 0 : PORTC = 1; break;
case 1 : PORTC = 5; break;
case 2 : PORTC = 4; break;
case 3 : PORTC = 6; break;
case 4 : PORTC = 2; break;
case 5 : PORTC = 10; break;
case 6 : PORTC = 8; break;
default : PORTC = 255; break;


} Delay_ms(50);
i++;
}

if(adc_ref < adc_y){

if(n<0){n=6;}

switch (n){
case 0 : PORTC = 1; break;
case 1 : PORTC = 5; break;
case 2 : PORTC = 4; break;
case 3 : PORTC = 6; break;
case 4 : PORTC = 2; break;
case 5 : PORTC = 10; break;
case 6 : PORTC = 8; break;
default : PORTC = 255; break;


}
Delay_ms(50);
n--;
}
}
} //~!

domingo, 4 de abril de 2010

Control

En esta semana se empesará a trabajar en el control de posicion para los motores que guian la pistola de gotchas, se utilizará un PID, se fijara al ele del motor a pasos un potenciometro, se introducira un valor de referencia (el cual se envía desde el procesamiento de imagen).

martes, 23 de marzo de 2010

Motor drivers

Ya hemos echado a jalar los motores de pasos usando como drivers un pic 16f877 como driver controlador, el siguiente paso es la comunicacion serial con la computadora para recibir las coordenadas resultantes del procesamiento de imagen.

martes, 16 de marzo de 2010

micros

Ya estan listotes los microcontroladores 16f877 que vamos a usar para los drivers de los motores, y comunicación con la computadora, de donde necesito:

saber la secuencia para programar los micros y controlar los motores y recibir de la computadora dos diferentes referencias, una en X y otra en Y para la localización del objetivo.

equipo de vision

Cambiamos de parecer, vamos mejor a utilizar Matlab, ya que cuenta con librerias especializadas para analisis de imagenes, y tiene funciones ya definidas como para reduccion de ruido, etc.
Ademas de que lo conseguimos sin costo alguno. Estamos consiguiendo la camara.. mas adelante dentro de esta semana mostraremos fotos de la camara

lunes, 1 de marzo de 2010

equipo de vision

estabamos viendo entre utilizar LabView, Matlab o VisualStudio
decidimos utilizar VisualStudio por ser software libre
ya estamos empezando a trabajar en eso

Avance del Motor a Pasos -Bernardo Jacquez


Por medio del uso de transistores tipo Darlington TIP41, cuya característica principal es el Drenar bastante corriente, se logro hacer una interface de potencia para hacer girar los motores. El problema es que la corriente para disparar el TIP41 es muy alta para ser alcanzada por el micro-controlador. Por lo que se comenzó a usar un ULN2003A para bajar la corriente de accionamiento. El problema fue que el Driver ULN2003A es simplemente un Darlington para drenar corriente, por lo que su voltaje de Colector-Emisor es muy alto al momento de la saturación. Por lo que mejor se utilizo un 2N2222A para disparar las Bases. Se utilizan en su configuración de switch pues el emisor va a la base del TIP41, mientras el Colector por medio de una resistencia de 1K ohm se conecta a la línea de 5 volts. La base del 2N2222A se dispara a través de una resistencia de 4.7 K ohm, lo cual es una corriente tan pequeña que se dispararía con la corriente del cuerpo humano, es decir con el simple hecho de tocarla.

A continuacion se muestran las fotos de como se conecto en un Protoboard.




También se muestra un video con la versión previa (sin micro-controlador) de lo que seria los drivers de muestra el motor StepSyn de Sanyo Denki modelo 103-814-6541 con alimentación de 12 Volts en configuración Unipolar.