jueves, 25 de abril de 2013

Controlar dos motores con arduino.

Del video anterior la rutina que se programo en el Arduino es muy simple, solo se mandan salidas altas o bajas dependiendo de como queremos que se comporte el motor.

La función del driver esta descrita en la tabla que publiqué anteriormente en la descripción del driver para manejar los motores.


En estas entradas también es muy útil inyectar una señal PWM en lugar de solo un 1 lógico para así controlar la velocidad del motor, la condición de motor bloqueado es para frenar el motor y mantenerlo sin movimiento, esto es mediante un campo magnético generado dentro del motor que evita que el rotor gire.

A continuación coloco el programa hecho para un arduino uno rev. 3, este programa solo controla la dirección de los motores, si se desea controlar la velocidad hay que cambiar las salidas lógicas por salidas PWM, la frecuencia que debe manejar el PWM debe ser alta por encima del rango de frecuencias audibles (mayor a 20KHz) para evitar que nuestros motores emitan sonidos molestos y al final del dia terminemos con dolor de cabeza (lo digo por experiencia propia XD)


int E1 = 0;    //Habilita o desablita la primera mitad del driver
int E2 = 1;    //Habilita o desablita la segunda mitad del driver

int m11 = 2;  //m11 y m12 son los bits de control del motor uno (en la tabla PIN5 PIN7)
int m12 = 3;

int m21 = 4;  //m21 y m22 son los bits de control del motor dos (en la tabla PIN10 PIN12)
int m22 = 5;

void setup() {                
      
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(E1, HIGH);    //ACTIVAR DRIVER
  digitalWrite(E2, HIGH);
  
  digitalWrite(m11, LOW);    //ADELANTE        
  digitalWrite(m12, HIGH);
  digitalWrite(m21, LOW);            
  digitalWrite(m22, HIGH);  
  delay(1500); 
  
  digitalWrite(m11, LOW);    //ALTO        
  digitalWrite(m12, LOW);
  digitalWrite(m21, LOW);            
  digitalWrite(m22, LOW);  
  delay(500); 
  
  digitalWrite(m11, LOW);    //IZQUIERDA 90°        
  digitalWrite(m12, HIGH);
  digitalWrite(m21, HIGH);            
  digitalWrite(m22, LOW);  
  delay(500);
  
  digitalWrite(m11, LOW);    //ALTO        
  digitalWrite(m12, LOW);
  digitalWrite(m21, LOW);            
  digitalWrite(m22, LOW);  
  delay(500); 
  
  digitalWrite(m11, LOW);    //ADELANTE        
  digitalWrite(m12, HIGH);
  digitalWrite(m21, LOW);            
  digitalWrite(m22, HIGH);  
  delay(1500);
  
  digitalWrite(m11, LOW);    //ALTO        
  digitalWrite(m12, LOW);
  digitalWrite(m21, LOW);            
  digitalWrite(m22, LOW);  
  delay(500);
  
  digitalWrite(m11, HIGH);    //DERECHA 90°        
  digitalWrite(m12, LOW);
  digitalWrite(m21, LOW);            
  digitalWrite(m22, HIGH);  
  delay(500);
  
  digitalWrite(m11, LOW);    //ALTO        
  digitalWrite(m12, LOW);
  digitalWrite(m21, LOW);            
  digitalWrite(m22, LOW);  
  delay(500);
  
  digitalWrite(m11, LOW);    //ADELANTE        
  digitalWrite(m12, HIGH);
  digitalWrite(m21, LOW);            
  digitalWrite(m22, HIGH);  
  delay(1500);
  
  digitalWrite(m11, LOW);    //IZQUIERDA        
  digitalWrite(m12, HIGH);
  digitalWrite(m21, LOW);            
  digitalWrite(m22, LOW);  
  delay(1500);
  
  digitalWrite(m11, LOW);    //DERECHA       
  digitalWrite(m12, LOW);
  digitalWrite(m21, LOW);            
  digitalWrite(m22, HIGH);  
  delay(1500);
  
  digitalWrite(m11, LOW);    //ALTO        
  digitalWrite(m12, LOW);
  digitalWrite(m21, LOW);            
  digitalWrite(m22, LOW);  
  delay(500);
  
  digitalWrite(m11, HIGH);    //REVERSA        
  digitalWrite(m12, LOW);
  digitalWrite(m21, HIGH);            
  digitalWrite(m22, LOW);  
  delay(2000);
  
  digitalWrite(m11, LOW);    //ALTO        
  digitalWrite(m12, LOW);
  digitalWrite(m21, LOW);            
  digitalWrite(m22, LOW);  
  delay(9000);
}  

martes, 23 de abril de 2013

Puente H para seguidor de linea

Aquí un ejemplo de como funciona Driver que se publico anteriormente.

También lo tengo disponible a la venta por solo $250.00 pesos si desean adquirir el circuito contáctenme



jueves, 4 de abril de 2013

Sensores para seguidor de linea.

1. Etapa de sensores

El primer circuito de sensores publicado anteriormente aquí en el blog carece de un circuito acondicionador de señal y el nivel de voltaje de la  señal proveniente de los fototransistores dependerá en gran medida de la impedancia de entrada del circuito de control al cual lo estemos conectando ya que la corriente suministrada por el fototransistor es muy pequeña.

Este nuevo sensor cuenta con un circuito de acondicionamiento de señal para evitar que el voltaje de salida de los sensores caiga y sea mas fácil manejaros al conectarlos a un microcontrolador o al Arduino.

Básicamente el circuito de los sensores es el mismo, se añadió el diseño del circuito en PCB para darle mejor presentación y manejarlo mas fácilmente; así como tener la seguridad de que no se desconectara algún cable en el momento de las pruebas.



El circuito esta compuesto de 5 sensores óptico-reflectivos QRD1114 el cual consta de un LED infrarrojo y un fototransistor, la resistencia de 220 es para limitar la corriente del LED a 22mA y evitar quemarlo, la alimentación (VCC) es de 5 volts, la resistencia de 10K es para cerrar el circuito entre el colector y el emisor y poder tener un voltaje de referencia en el emisor que sera proporcional a la cantidad de luz  proveniente del LED reflejada hacia el fototransitor al acercar el sensor a alguna superficie; es del emisor del fototransitor de donde se toma la señal que se acondicionara para tener un nivel de voltaje estable.

El diseño del PCB se realizo de la siguiente manera colocando los sensores en una forma de arco suave, aunque la mejor forma de colocarlos es dependiendo del tipo de linea que va a detectar el robot y la complejidad de la pista, a mi me funciono esta posición pero tal vez no sea la mas eficiente.






2. Acondicionador de Señal.

El acondicionador de señal esta compuesto únicamente por 5 amplificadores operacionales en configuración de seguidor de voltaje, lo que hace este circuito es proveer una alta impedancia de entrada evitando caídas de voltaje en el emisor del sensor y dando a la salida el mismo nivel de voltaje.




A continuación el diseño del circuito en PCB, el circuito es muy sencillo, la pista en color rojo es un puente y las medidas de la baquelita son 5mm x 5mm.



El circuito terminado queda en dos módulos independientes que se ensamblan uno con otro mediante pines hembra y macho, el conjunto de pines del circuito acondicionador de señal identificado con el nombre de "SENSORES" debe ser conectado con el conjunto de pines del PCB de los sensores; el conjunto de pines con la leyenda "SALIDA" debe ser alimentado con el voltaje del Arduino de 5V, el pin que dice 0V es tierra (gnd) y las salidas del 1 al 5 son las salidas de cada sensor que serán conectadas a la entrada analógica del Arduino o microcontrolador que estemos utilizando.

A continuación les dejo unas fotos del par de circuitos conectados entre si.



Por ultimo en el siguiente link se pueden descargar el PDF para imprimir los circuitos y revelarlos.




miércoles, 27 de marzo de 2013

Controlar la dirección y velocidad del robot

Driver para seguidor de linea.

Este nuevo driver basado en un circuito integrado L298N que en esencia es lo mismo que el que se uso anteriormente (L293) con la diferencia de que soporta mayor corriente y podremos utilizar motores de CD mas grandes.

El L298N es un circuito integrado encapsulado en multiwatt 15. es un driver de puente completo de alto voltaje y alta corriente diseñado para aceptar niveles lógicos estandard TTL y manejar cargas inductivas como relevadores, solenoides, motores de CD y motores de pasos. Esta provisto de dos entradas de eneable para activar o desactivar los dos puentes independientemente de las entradas de señal. Los emisores de los transistores mas bajos de cada puente están conectados juntos y la terminal externa correspondiente puede ser usada para la conexión de una resistencia shunt (para sensar corrientes).
- Opera con una fuente de voltaje de hasta 46V
- Corriente de CD hasta 4A
- Bajo voltaje de saturación
- Protección contra sobrecalentamiento
- Voltaje de 0 lógico de entrada hasta 1.5 (Alta inmunidad al ruido)

El diagrama de pines es el siguiente:



Se agregaron dos reguladores de voltaje, uno de 5V y otro de 3.3V para alimentar algunos sensores y otros CI que agreguemos a nuestros diseños.

A continuación se muestra el esquemático del circuito.


Podremos alimentar con una batería de hasta 15V en el borne indicado con la leyenda de BATERIA; esto para no dañar el regulador de 3.3V.

Las entradas de control nombradas IN1 e IN2 son las encargadas de recibir las señales provenientes de un microcontrolador o cualquier otro circuito de control para determinar la dirección de los motores que  se conectaran al borne llamado MOTORES un motor deberá conectarse a los pines 1 y 2 del borne y el otro a los pines 3 y 4. En la siguiente tabla se muestra como se comporta la salida respecto a la entrada.


Finalmente este es el diseño en PCB del circuito, dejo también un link para descargar el esquemático y el layout si es que lo quieren modificar, fue creado en ISIS y ARES de Proteus.








sábado, 16 de abril de 2011

NuEvOoOoO!!!!

PROXIMAMENTE POV LED DISPLAY CON ARDUINO!!!!!!!!!

BANNER FLOTANTE



6 LEDS AL GIRAR A GRAN VELOCIDAD DAN EL EFECTO DE TENER UN BANNER DE LEDS SUSPENDIDO EN EL AIRE :)

viernes, 21 de enero de 2011

Robot Seguidor de Linea con ARDUINO

Este blog ha sido creado con la finalidad compartir paso a paso como desarrollar un robot seguidor de linea negra utilizando una placa de ARDUINO UNO, la construcción es muy sencilla al igual que la programación, cabe mencionar que este diseño gano el concurso de robótica RACEBOT.T. IEEE 2010 llevado a cabo en el Instituto Tecnológico de Toluca

1. Materiales Utilizados en el proyecto.



- Una tarjeta ARDUINO UNO (cualquier versión sirve)



- Circuito Integrado L293B


- Dos moto-reductores (se adaptaron unos de un robot de juguete que tenia de niño pero pueden utilizar unos como estos cuestan al rededor de $60.00 pesos)




- 8 diodos 1n4148


- 5 Sensores óptico-refletcivos QRD1114


- Ruedas. Para construir este robot se emplearon 2 ruedas fueron compradas en una tienda de electrónica y una rueda loca que diseño con piezas de mecano

- Y lo mas importante ¡¡MUCHA IMAGINACIÓN!!
Añadir imagen

2. Construcción de la base del robot

Esta parte del proyecto es muy importante ya que de ella depende la movilidad del robot así como de su rigidez para soportar los elementos electrónicos que posteriormente se integrarán a el.

Se eligió como soporte un pequeño trozo de acrílico de 3mm de espesor y aproximadamente 20cm de largo y 10cm de ancho; el acrílico es muy fácil de manejar de hecho se puede cortar con un cutter y una regla repasando varias veces sobre el.

La rueda loca (llamada graciosamente así) es una rueda igual a la que usan los carritos de supermercado y las sillas de oficina (igual en concepto, no físicamente) esta tiene un movimiento libre de 360º que facilita los giros del robot; la rueda loca implementada en este proyecto fue construida con piezas de mecano y una llanta de un carrito de juguete; pero también se pueden encontrar en tiendas de electrónica o robótica unas muy bonitas y no tan pesadas. A continuación muestro una foto de la rueda.

Y por último pero no menos importante la parte de tracción del robot; constituida por los dos moto-reductores y sus respectivas ruedas, cada uno de estos puede ser controlado independientemente y son los que le dan dirección al robot, cabe destacar que si uno gira en sentido opuesto al otro respectivamente se puede obtener un giro de 360º sobre el eje del robot, lo que permite un amplio rango de movimiento.

Este es el aspecto final de la construcción del chasis del robot seguidor de linea que hemos bautizado BICHIBOT XD



jueves, 20 de enero de 2011

3. Diseño del driver para los motores.



En esta etapa de la construcción del robot BICHIBOT trata sobre el diseño de un controlador bidireccional para motores de corriente directa, que esta constituido de un Circuito Integrado L293B.

El L293B (datasheet) es un driver de 4 canales capaz de proporcionar una corriente de salida de hasta 1A por canal. Cada canal es controlado por señales de entrada compatibles TTL y cada pareja de canales dispone de una señal de habilitación que desconecta las salidas de los mismos.

Dispone de un pin para la alimentación de las cargas que se están controlando, de forma que dicha alimentación es independiente de la lógica de control.

La siguiente imagen describe la conexión básica de un motor al driver y en la tabla se muestra las señales de control, +Vs es el pin de alimentación de los motores

imagen y tabla de Carlos Canto Q.

La conexión del circuito aparece en el siguiente diagrama esquemático, los motores se conectan a los pines OUT1 y OUT2 para el primer motor y OUT3 y OUT4 para el segundo. Los diodos (1N4148) que van conectados a los motores son de protección contra sobrecorrientes de retorno debido a la conmutación de las bobinas de los mototes; evitando asi un sobrecalentamiento o posibles daños al driver.

Nota: El diagrama incluye un regulador de voltaje 7805, podemos descartarlo en el diseño ya que la placa de arduino cuenta con un regulador y pines que entregan 3.3V y 5V pero si se desea incluir algunos componentes extras es recomendable alimentarlos mediante la salida de este regulador para no sobrecargar al Arduino.

Para facilitarles la vida PDF listo para imprimir y hacer el PCB del diagrama anterior!!!! CLICK AQUÍ

miércoles, 19 de enero de 2011

Manual de ARDUINO en Español!!!!!!!

Para saber mas aqui les dejo este manual creado por Rafael Enríquez Herrador espero que les sirva es muy facil de entender y a mi parecer viene muy bien explicado Download

martes, 18 de enero de 2011

4. Programa para el Robot Seguidor de Linea.

El programa hecho para este robot es muy básico y puede ser modificado para mejorar el control del robot, se puede agregar auto ajuste de sensibilidad a la luz de los sensores, medidor de nivel de batería, algún sonido o cualquier otra cosa útil en el desempeño del robot.

int Sen1 = 0; //Extremo izquierdo
int Sen2 = 1; //Izquierdo
int Sen3 = 2; //Centro
int Sen4 = 3; //Derecho
int Sen5 = 4; //Extremo Derecho

int Val1 = 0; // Valor de los sensores
int Val2 = 0;
int Val3 = 0;
int Val4 = 0;
int Val5 = 0;
//Control de los motores
int Azul = 6;
int Gris = 9;
int Cafe = 10;
int Negr = 11;

int x = 650; //Diferencia entre negro y blanco (Valor > x = Negro).

int Vel0 = 100;
int Vel1 = 155; // Especificar velocidad de
int Vel2 = 190; // motores en el giro.
int Vel3 = 230;
int Vel = 255;

void setup()
{
pinMode(Azul, OUTPUT);
pinMode(Gris, OUTPUT);
pinMode(Cafe, OUTPUT);
pinMode(Negr, OUTPUT);
Serial.begin(9600);
}
void loop()
{
//Lectura y registro de los valores de los sensores
Val1 = analogRead(Sen1);
Val2 = analogRead(Sen2);
Val3 = analogRead(Sen3);
Val4 = analogRead(Sen4);
Val5 = analogRead(Sen5);
//Direccionamiento del robot
if ((Val1 < x)&&(Val2 < x)&&(Val3 > x)&&(Val4 < x)&&(Val5 < x))
{
analogWrite(Azul, 0);
analogWrite(Gris, 0);
analogWrite(Cafe, Vel);
analogWrite(Negr, Vel);
}
else if ((Val1 < x)&&(Val2 > x)&&(Val3 > x)&&(Val4 < x)&&(Val5 < x))
{
analogWrite(Azul, 0);
analogWrite(Gris, 0);
analogWrite(Cafe, Vel1);
analogWrite(Negr, 0);
}
else if ((Val1 < x)&&(Val2 < x)&&(Val3 > x)&&(Val4 > x)&&(Val5 < x))
{
analogWrite(Azul, 0);
analogWrite(Gris, 0);
analogWrite(Cafe, 0);
analogWrite(Negr, Vel1);
}
else if ((Val1 < x)&&(Val2 < x)&&(Val3 < x)&&(Val4 > x)&&(Val5 < x))
{
analogWrite(Azul, 0);
analogWrite(Gris, 0);
analogWrite(Cafe, 0);
analogWrite(Negr, Vel2);
}
else if ((Val1 < x)&&(Val2 < x)&&(Val3 < x)&&(Val4 > x)&&(Val5 > x))
{
analogWrite(Azul, 0);
analogWrite(Gris, 0);
analogWrite(Cafe, 0);
analogWrite(Negr, Vel3);
}
//*********!!!!!!!!!
else if ((Val1 < x)&&(Val2 < x)&&(Val3 < x)&&(Val4 < x)&&(Val5 > x))
{
analogWrite(Azul, 0);
analogWrite(Gris, 0);
analogWrite(Cafe, 0);
analogWrite(Negr, Vel);
}
else if ((Val1 < x)&&(Val2 > x)&&(Val3 < x)&&(Val4 < x)&&(Val5 < x))
{
analogWrite(Azul, 0);
analogWrite(Gris, 0);
analogWrite(Cafe, Vel2);
analogWrite(Negr, 0);
}
else if ((Val1 > x)&&(Val2 > x)&&(Val3 < x)&&(Val4 < x)&&(Val5 < x))
{
analogWrite(Azul, 0);
analogWrite(Gris, 0);
analogWrite(Cafe, Vel3);
analogWrite(Negr, 0);
}
else if ((Val1 > x)&&(Val2 < x)&&(Val3 < x)&&(Val4 < x)&&(Val5 < x))
{
analogWrite(Azul, 0);
analogWrite(Gris, 0);
analogWrite(Cafe, Vel);
analogWrite(Negr, 0);
}
else if ((Val1 < x)&&(Val2 < x)&&(Val3 > x)&&(Val4 > x)&&(Val5 > x))
{
analogWrite(Azul, 0);
analogWrite(Gris, Vel);
analogWrite(Cafe, 0);
analogWrite(Negr, Vel2);
delay(250);
}
else if ((Val1 > x)&&(Val2 > x)&&(Val3 > x)&&(Val4 < x)&&(Val5 < x))
{
analogWrite(Azul, Vel);
analogWrite(Gris, 0);
analogWrite(Cafe, Vel2);
analogWrite(Negr, 0);
delay(250);
}
else if ((Val1 > x)&&(Val2 < x)&&(Val3 > x)&&(Val4 < x)&&(Val5 < x))
{
analogWrite(Azul, Vel);
analogWrite(Gris, 0);
analogWrite(Cafe, Vel2);
analogWrite(Negr, 0);
delay(250);
}
else if ((Val1 < x)&&(Val2 < x)&&(Val3 > x)&&(Val4 < x)&&(Val5 > x))
{
analogWrite(Azul, 0);
analogWrite(Gris, Vel);
analogWrite(Cafe, 0);
analogWrite(Negr, Vel2);
delay(250);
}
else if ((Val1 > x)&&(Val2 > x)&&(Val3 > x)&&(Val4 > x)&&(Val5 > x))
{
analogWrite(Azul, Vel);
analogWrite(Gris, 0);
analogWrite(Cafe, Vel2);
analogWrite(Negr, 0);
delay(250);
}
else if ((Val1 < x)&&(Val2 < x)&&(Val3 < x)&&(Val4 < x)&&(Val5 < x))
{
analogWrite(Azul, Vel);
analogWrite(Gris, Vel);
analogWrite(Cafe, 0);
analogWrite(Negr, 0);
delay(200);
analogWrite(Azul, 0);
analogWrite(Gris, 0);
analogWrite(Cafe, Vel);
analogWrite(Negr, Vel);
}
}

4. Sensores para la detección de la linea.

Aquí se describe la construcción del sensor que está constituido de 5 QRD1114 (pueden utilizar CNY70 o algún otro sensor óptico-reflectivo)

Para la polarización de estos es necesario un resistor de 220 ohm y uno de 4.7Kohm y los conectaremos como se muestra en el circuito. Véase datasheet QRD1114
El diagrama anterior representa la conexión de un solo sensor; es necesario repetir 5 de estos circuitos. La linea que indica SALIDA es el voltaje que entregara el sensor, que es proporcional a la cantidad de luz reflejada por alguna superficie y recibida por el fototransistor.

En este caso se han acomodado los QRD1114 de la siguiente manera; pero si asi se cree conveniente se pueden agregar u omitir sensores.

Una vez montado el circuito y polarizado se puede comprobar que todos los LEDs infrarrojos de los QRD1114 encienden mediante una cámara digital (podemos usar la de nuestro celular) y se verán con una luz en un tono violeta.


Para asegurarnos que los fototransistores de los QRD1114 están trabajando correctamente deberemos comprobar el voltaje de las salidas. Con una superficie reflectante (un trozo de papel blanco) deberemos obtener un voltaje superior a 3 volts aproximadamente; en ausencia de algún objeto que refleje la luz infrarroja emitida por los LEDs mediremos aproximadamente 1 volt, este valor puede variar dependiendo de la luz del ambiente en el que estemos trabajando, aspecto que debe ser considerado en la programación del robot.

Con esto hemos terminado la parte electrónica y mecánica de nuestro robot, resta conectar todo a nuestro Arduino y comenzar con la programación.