ROBOT POR COMANDOS DE VOZ Y RECONOCIMIENTO DE COLORES¶

Un Robot es una maquina automática y programable capaz de realizar determinadas funciones, en este caso por medio de comandos de voz realizará ciertas rutinas de movimiento y reconocerá colores y dependiendo de esto generará tonos de diferentes frecuencias.

MANUAL DEL USUARIO¶

Descripción General: A continuación, se hará la descripción paso a paso para lograr implementar el movimiento de dos motores NEMA en diferentes sentidos, la lectura de colores primarios y distinción por un sonido característico del buzzer. El robot luego de ensamblado lograra moverse los pasos que sean solicitados por el usuario hacia adelante, atrás, derecha e izquierda, detectara los colores primarios y según el color el buzzer ejecutara un sonido diferente por color.

RECOMENDACIONES GENERALES¶

• No manipular él sensor o la board con las manos húmedas.

• Verificar la corriente del driver con ayuda de un multímetro y ajustar antes de iniciar la conexión con el NEMA17, recordando que los consumos máximos de los motores son de 2A.

• No deje al descubierto los componentes electrónicos del robot, la batería ni el cargador de la batería. Dentro no hay piezas que pueda reemplazar el usuario.

EJECUTABLES¶

• Plataforma virtual Mbed, https://www.mbed.com/en/

Para iniciar a crear el código se debe acceder a la página https://www.mbed.com/en/ en donde encontraran lo siguiente:

Damos click sobre el usuario de allí se despliega la siguiente página en donde seleccionamos Sing up

Registramos los datos para crear un usuario.

Una vez creado el usuario ingresamos a la plataforma

Ventana de inicio al programa, seleccione “compiler”

Se abrirá la ventana donde se debe seleccionar la tarjeta a utilizar que en este caso es la STM32L476

Seleccionar tarjeta

Al seleccionar la tarjeta se encontrarán dos ventanas, la primera da una descripción general de la tarjeta y en la segunda se encuentra el “Pinout” de la misma.

Ahora ya está listo para ingresar el codigo.

https://ide.mbed.com/compiler/#nav:/ROBOT_VOZ_COLOR/main.cpp

1. include "mbed.h"

1. include "scolor_TCS3200.h"

Serial command(USBTX, USBRX);

AnalogIn analog_M1(A5);

AnalogIn analog_M2(A4);

PwmOut mybuzzer(D9);

DigitalOut stepper_step(PB_8);

DigitalOut steppeer_dir(PB_9);

DigitalOut stepper_step_2(PA_7);

DigitalOut steppeer_dir_2(PA_6);

S0, S1, S2, S3, OUT

scolor_TCS3200 scolor(PA_8, PB_10, PB_4, PB_5, PB_3);

1. define INITCMD 0xFF

1. define VELOCITY 5000

1. define SENSOR 0x00

1. define TONO_1 0x01

1. define TONO_2 0x02

1. define TONO_3 0x03

1. define TONO_4 0x04

1. define UP 0x05

1. define DOWN 0x06

1. define LEFT 0x07

1. define RIGTH 0x08

1. define VEL 0x09

1. define JOS 0x0A

1. define DO 150

1. define RE 200

1. define MI 250

1. define FA 300

definición de las variables globales

uint8_t tip_mov;

uint8_t n_vueltas;

uint8_t STEEP;

float velocidad=500;

uint8_t tiempo;

uint8_t stop=0;

bool enable=0;

bool b=0;

float meas_X;

float meas_Y;

definición de las funciones

void setup_uart();

void mover_steper_nema();

void leer_datos();

void funcion_pasos();

void funcion_pasos_2();

void buzzer_on();

void leer_color();

void funcion_jos();

int main() {

setup_uart();

while(1){

leer_datos();

mover_steper_nema();

}

}

void setup_uart(){

command.baud(115200);

}

void leer_datos(){

while(command.getc()!= INITCMD);

tip_mov=command.getc();

n_vueltas=command.getc();

}

void mover_steper_nema(){

switch (tip_mov){

case SENSOR:

if (n_vueltas == 0)

{leer_color();}

printf("LEER COLOR\n");

break;

case TONO_1:

mybuzzer.write(0);

mybuzzer.period_ms(DO);

buzzer_on();

printf("TONO 1\n");

break;

case TONO_2:

mybuzzer.write(0);

mybuzzer.period_ms(RE);

buzzer_on();

printf("TONO 2\n");

break;

case TONO_3:

mybuzzer.write(0);

mybuzzer.period_ms(MI);

buzzer_on();

printf("TONO 3\n");

break;

case TONO_4:

mybuzzer.write(0);

mybuzzer.period_ms(FA);

buzzer_on();

printf("TONO 4\n");

break;

case UP:

steppeer_dir=1;

steppeer_dir_2=0;

STEEP=200;

funcion_pasos();

printf("MOVER ADELANTE\n");

break;

case DOWN:

steppeer_dir=0;

steppeer_dir_2=1;

STEEP=200;

funcion_pasos();

printf("MOVER ATRAS\n");

break;

case LEFT:

steppeer_dir=1;

steppeer_dir_2=1;

STEEP=50;

funcion_pasos_2();

printf("MOVER IZQUIERDA\n");

break;

case RIGTH:

steppeer_dir=0;

steppeer_dir_2=0;

STEEP=50;

funcion_pasos_2();

printf("MOVER DERECHA\n");

break;

case VEL:

if (n_vueltas==1)

{velocidad = 250;}

else if (n_vueltas==2)

{velocidad = 500;}

else if (n_vueltas==3)

{velocidad = 750;}

printf("%f \n", velocidad);

break;

case JOS:

if (n_vueltas==1)

{stop=1;}

funcion_jos();

if (n_vueltas==2)

{stop=0;}

break;

}

}

void funcion_pasos()

{ wait_us(velocidad);

for (int a=0; a<n_vueltas; a++){

for(int i=0; i<STEEP; i++)

{

stepper_step=1;

stepper_step_2=1;

wait_us(velocidad);

stepper_step=0;

stepper_step_2=0;

wait_us(velocidad);

printf("i");

}

}

}

void funcion_pasos_2()

{ wait_us(velocidad);

for(int i=0; i<STEEP; i++)

{

stepper_step=1;

stepper_step_2=1;

wait_us(velocidad);

stepper_step=0;

stepper_step_2=0;

wait_us(velocidad);

printf("i");

}

}

void leer_color(){

long red = scolor.ReadRed();

long green = scolor.ReadGreen();

long blue = scolor.ReadBlue();

long clear = scolor.ReadClear();

if (red>=5 and red <=21) lee el rojo----

{

if (green >=50 and green<=63)

{

if (blue>=43 and blue <=55)

{

printf("|FE 01|\n");

} } }

if (red >=5 and red<=65) lee el verde --------

{

if (green>=43 and green <=47)

{

if (blue>=55 and blue <=60)

{

printf("|FE 03|\n");

} } }

if (red >=5 and red <=70) lee el azul--------

{

if (green>=37 and green <=41)

{

if (blue>=21 and blue <=25) {

printf("|FE 02|\n");

} } }

if (red >=5 and red <=15) lee el amarillo--------

{

if (green>=4 and green <=15)

{

if (blue>=24 and blue <=38)

{

printf("|FE 04|\n");

} } }

if (red >=15 and red <=200) lectura errada--------

{

if (green >=170)

{

if (blue >=150)

{

printf("|FE 00|\n");

}

} }

printf("RED: %5d GREEN: %5d BLUE: %5d CLEAR: %5d \n ", red, green, blue, clear);

}

void buzzer_on()

{ tiempo = n_vueltas;

mybuzzer.write(0.5);

wait(tiempo);

mybuzzer.write(0);

}

void funcion_jos()

{

while (stop) {

meas_X=analog_M1.read();

meas_Y=analog_M2.read();

printf(" X=%2f Y=%2f \n",meas_X, meas_Y);

wait(1);

if (meas_X>=0.8)

{steppeer_dir=1;

steppeer_dir_2=0;

wait_us(2000);

STEEP+=200;

for(int i=0; i<STEEP; i++)

{ stepper_step=1;

stepper_step_2=1;

wait_us(velocidad);

stepper_step=0;

stepper_step_2=0;

wait_us(velocidad);

printf("%d %d\n", STEEP,i);

}

}

if (meas_X<=0.2)

{steppeer_dir=0;

steppeer_dir_2=1;

STEEP+=200;

for(int i=0; i<STEEP; i++)

{ stepper_step=1;

stepper_step_2=1;

wait_us(velocidad);

stepper_step=0;

stepper_step_2=0;

wait_us(velocidad);

printf("%d %d\n", STEEP,i);

}

}

if (meas_Y>=0.8)

{steppeer_dir=1;

steppeer_dir_2=1;

STEEP=50;

for(int i=0; i<STEEP; i++)

{ stepper_step=1;

stepper_step_2=1;

wait_us(velocidad);

stepper_step=0;

stepper_step_2=0;

wait_us(velocidad);

printf("%d %d\n", STEEP,i);

}

}

if (meas_Y<=0.2)

{steppeer_dir=0;

steppeer_dir_2=0;

STEEP=50;

for(int i=0; i<STEEP; i++)

{ stepper_step=1;

stepper_step_2=1;

wait_us(velocidad);

stepper_step=0;

stepper_step_2=0;

wait_us(velocidad);

printf("%d %d\n", STEEP,i); }

}

}

}

Una vez compile el código, la plataforma generara un archive .bin; este debe ser cargado directamente a la tarjeta como si se estuviera cargando a una USB, ya que funciona prácticamente de la misma manera.

¿Como conectar la tarjeta STM32L476?

La tarjeta trae un puerto mini USB, que se conecta por medio del cable al puerto USB del computador donde se realizará la programación. En el momento que se compila un nuevo programa se dará cuenta que uno de los led de la tarjeta titila varias veces indicando el proceso de compilado (Ver compilación en la descripción de MBED en manual tecnico).

• Software Cool term (Permite crear una interfaz para recibir y enviar telecomandos)

Luego de conocer las características y funciones de cada uno de los componentes debe compilar el siguiente código con ayuda de *mbed* y cargarlo a la board STM32L476RG deberá instalar *coolterm* para enviar y recibir los telecomandos necesarios los cuales controlan los movimientos y las acciones del Robot.

COOLTERM¶

Es una sencilla aplicación que permite tener una terminal para los puertos serie, su menú de configuración está muy completo, permitiendo elegir desde una lista los puertos disponibles y seleccionar su velocidad y demás parámetros; despliega los datos recibidos tanto en ascii como en hexadecimal. Sin duda una gran aplicación para los que hacemos uso de este protocolo constantemente para conexión del ordenador con microcontroladores, módulos USB-serial, GPS, controladores de servos, etc. Lo mejor de todo está bajo una licencia freeware y es multiplataforma. Con CoolTerm se logrará generar las señales necesarias para que el programa ejecute las funciones.

Para obtener coolterm debemos ingresar a la siguiente página http://freeware.the-meiers.org/

La descarga se realiza de acuerdo al sistema operativo de la computadora en donde se trabaje.

El Coolterm se descarga en una carpeta comprimida en donde se debe seleccionar el ejecutable.

Seleccionar ejecutar.

Seleccionamos “Connect“

Por medio de este programa se envía la señal FF XX para que se ejecute el programa del código ya mencionado.

Escribimos “FF”, que es el comando que inicia el programa.

Dele click en “Send”, para enviar el comando hexadecimal y automáticamente el buzzer sonará con frecuencias diferentes y aparte de esto el sensor detectara los colores correspondientes como también si no tiene filtro y enviara la respuesta por medio programa ya mencionado. El control de movimiento de los motores también tendrá comandos, telecometrias y parametros que representaran el tipo de movimiento, en este caso “adelante, atrás, derecha, izquierda”, seguido por el numero de vueltas y velocidad.

La siguiente tabla indica cada comando impreso con su definición:

Algunos ejemplos de como ingresar las telemetrias:

DIAGRAMA DE CONEXIÓN GENERAL¶

MANUAL TECNICO¶

REQUERIMIENTOS MÍNIMOS DE HARDWARE¶

Para la creación del robot es necesario:

• PC (Procesador : Core, Memoria RAM: Mínimo : 1 Gigabytes (GB), Disco Duro : 500Gb)

• Tarjeta STM32L476

• Sensor de color TCS3200

• Buzzer

• Motores Nema 17

• Drivers 8825

REQUERIMIENTOS DE SOFTWARE¶

• Plataforma virtual *Mbed*, https://www.mbed.com/en/

• Software *Cool term* (Permite crear una interfaz para recibir y enviar telecomandos)

INFORMACIÓN DE ELEMENTOS¶

A continuación, encontrará la descripción de los componentes utilizados para la ejecución de las funciones del código.

STM32L476¶

La placa STM32 Núcleo proporciona una forma asequible y flexible para que los usuarios prueben nuevas ideas y construyan prototipos con cualquier línea de microcontrolador STM32, eligiendo entre las diversas combinaciones de rendimiento, consumo de energía y características. La tarjeta tiene unas especificaciones básicas que debes de tener en cuenta

• Habilitado para mbed (http://mbed.org)

• Alimentación placa Flexible

o VBUS USB o fuente externa (3,3 V, 5 V, 7-12 V)

o Punto de Acceso para gestión de potencia

• Tres LEDs

o Comunicación USB (LD1) LED de usuario (LD2) de LED (LD3)

• Dos pulsadores: usuario y reinicio

• Capacidad de reenumeración USB: tres interfaces diferentes compatibles con USB

o Puerto Com Virtual

o Almacenamiento en masa

o Puerto de depuración

SENSOR DE COLOR TCS3200¶

• Alta resolución de conversión de luz a frecuencia.

• Frecuencia de salida Programable en color y escala completa.

• Se comunica directamente con un microcontrolador.

• Voltaje de funcionamiento: 2.7-5.5 V.

• Rango de error típicamente de 0,2% a 50 kHz.

• Coeficiente de temperatura 200 ppm/°C .

PRINCIPIO DE FUNCIONAMIENTO

El TCS3200 va detectar colores rojo, verde, azul y amarillo. en el monitor serial se mostrara la cantidad que color es de acuerdo a los rangos que definimos, estos deben ser previamente analizados desde el datasheet para poder ser definidos.

FUNCION DE TERMINALES

OPCIONES

MOTOR PASO A PASO NEMA17¶

CARACTERISTICAS GENERALES

• Tamaño: 42 mm x 38 mm cuadrados, sin incluir el eje (NEMA 17)

• Peso: 285g (10 onzas)

• Diámetro: 5 mm

• Pasos por revolución: 200

• Corriente: 1.68A por bobina

• Voltaje: 2.7 V

• Resistencia: 1.65 Ohm por bobina

• Torque: 3.7Kg-cm (51 onzas-in)

• Inductancia: 3.2 mH por bobina

• Longitud del cable: 30.48 cm

PRINCIPIO DE FUNCIONAMIENTO

Básicamente estos motores están constituidos normalmente por un rotor sobre el que van aplicados distintos imanes permanentes y por un cierto número de bobinas excitadoras bobinadas en su estator. Las bobinas son parte del estator y el rotor es un imán permanente. Toda la conmutación (o excitación de las bobinas) deber ser externamente manejada por un controlador.

En este caso se utilizará motores bipolares.

Estos tienen generalmente cuatro cables de salida. Necesitan ciertos requerimientos para ser controlados, debido a que requieren del cambio de dirección del flujo de corriente a través de las bobinas en la secuencia apropiada para realizar un movimiento.

Secuencias para manejar motores paso a paso Bipolares

Como se dijo anteriormente, estos motores necesitan la inversión de la corriente que circula en sus bobinas en una secuencia determinada. Cada inversión de la polaridad provoca el movimiento del eje en un paso, cuyo sentido de giro está determinado por la secuencia seguida. A continuación, se puede ver la tabla con la secuencia necesaria para controlar motores paso a paso del tipo Bipolares:

DRIVER A4988¶

son controladores que simplifican el manejo de motores paso a paso desde un autómatao procesador.

Estos controladores nos permiten manejar los altos voltajes e intensidades que requieren estos motores, limitar la corriente que circula por el motor, y proporcionan las protecciones para evitar que el hardware pueda resultar en daño.

Para su control únicamente requieren dos salidas digitales, una para indicar el sentido de giro y otra para comunicar que queremos que el motor avance un paso. Además, permiten realizar microstepping, una técnica para conseguir precisiones superiores al paso nominal del motor. El A4988 ha alcanzado una gran popularidad en sus últimos tiempos debido a su uso en proyectos como, por ejemplo, en impresoras 3D caseras.

FUNCIONAMIENTO DEL A4988

Como en la mayoría de los controladores de motores el componente fundamental es un puente-H. En el caso del A4988, controladores de motores paso a paso, se dispone de dos puentes-H (uno por canal) constituidos por transistores MOSFET.

Unicamente requieren dos señales digitales de control para hacer funcionar el motor e incorporan las protecciones necesarias para su manejo, su electrónica incorpora funciones especialmente diseñadas para el control de motores paso a paso, como son el regulador de intensidad y el Microstepping. Los controladores incorporan un limitador de intensidad, que permiten alimentar el motor a tensiones nominales superiores a las que es posible por su resistencia e intensidad máxima admisible.

MICROSTEPPING

El microstepping es una técnica que permite obtener pasos inferiores al paso nominal del motor paso a paso que vamos a controlar, hace variar la corriente aplicada a cada bobina emulando un valor analógico. Si pudiéramos a ambas bobinas dos señal, eléctrica y senoidal perfecta desfasadas 90º conseguiríamos un campo magnético rotatorio perfecto en el interior del motor.

El resultado es un campo magnético un campo magnético rotativo con un paso inferior al paso nominal, que depende del número de niveles de discretos que podemos emplear en las señales de excitación de la bobina. Cuando no se hace uso del microstepping (Modo full step), los controladores aplican una secuencia de 2-fases, por lo que aplican de forma permanente el 71% de la corriente del limitador a cada bobina. Únicamente varían el sentido en el que la corriente circula por la bobina.

ESQUEMA DE MONTAJE

MÓDULO JOYSTICK¶

El módulo Joystick, permite construir un controlador manual en 2 direcciones: X y Y. Posee ademas la función de pulsador que se activa al presionar el Joystick. Posee dos potenciometros cada uno con su salidas analógica para la dirección (VRx-VRy) y una salidad digital del pulsador (SW). Para leer la posición es necesario convertir los valores analógicos utilizando un ADC de el controlador a utilizar.

Empleado en proyectos de robótica, control, automatización, videojuegos.

ESPECIFICACIONES TÉCNICAS¶

• Voltaje de Operación: 3.3 - 5V DC

• 2 Potenciometros

• 1 Pulsador