Carro por comando de voz
You are viewing an older revision! See the latest version
Manual
Carro: Lector De Color¶
El siguiente articulo presenta los manuales de usuario y técnico del sistema Carro: Lector de color, el cual tiene como base el programa "Carro", esto para dar explicación de como funciona este sistema.
El manual técnico presenta una explicación detallada de como trabaja software y hardware en conjunto; el programa desarrollado en la plataforma MBED, sera la base para poder manejar el hardware (Sensor, buzzer, joystick y motores) en función del sistema.
El manual de usuario, contiene las instrucciones para que el cliente pueda dar uso del sistema, cabe aclarar que aquí no se le dará una explicación extensa, solo lo suficiente para poder poner en marcha el prototipo correctamente.
MANUAL DE TÉCNICO¶
El sistema contara con los siguientes hardware:
Tarjeta Núcleo STM F411RE:
Tarjeta de desarrollo y programación para micros de la línea STM32. Cuenta con un micro STM32F4 de 64 pines, memoria Flash 512 KB y con conectores STMicroelectronics Morpho con accesos a todos los pines del micro. Su alimentación por USB VBUS o fuente externa (3.3 V, 5 V, 7 - 12 V)
Sensor TCS3200:
El sensor de color TCS3200 de la arca LC Tech es un convertidor de luz a frecuencia que combina fotodiodos de silicio reconfigurables y una corriente de frecuencia en un solo circuito integrado. La salida es una onda cuadrada (ciclo de trabajo 50%) con una frecuencia directamente proporcional a la intensidad de luz. Las entradas y salidas digitales permiten una interfaz directa con un micro-controlador u otro conjunto de circuitos lógicos.
Los pines de conexión están repartidos de la siguiente forma:
S0 | S1 | Escala de la frecuencia de salida | S2 | S3 | Tipo Fotodiodo | |
---|---|---|---|---|---|---|
H | H | 100% | H | H | Verde | |
H | L | 20% | H | L | Sin filtro | |
L | H | 2% | L | H | Azul | |
L | L | Power Down | L | L | Rojo |
Habiendo configurado el sensor de acuerdo a lo que se requiera el pin de salida mandara una señal cuadrática de un periodo de 50%, la manera de recopilar el color de cada fotoreceptor no es un valor tan evidente, además necesita de calibración que veremos en la siguiente lección. Pero saber que no hay que medir el valor de la amplitud de la señal, sino su frecuencia.
Buzzer:
Es un pequeño transductor capaz de convertir la energía eléctrica en sonido. Para hacerlos funcionar solo basta conectar el positivo con el + y la tierra o negativo con el – de una batería o cualquier fuente de corriente directa.
Joystick:
es un dispositivo de entrada para un controlador (a menudo un controlador de juegos ) que se usa para entrada bidimensional. Un stick analógico es una variación de un joystick , que consiste en una protuberancia del controlador; la entrada se basa en la posición de esta protuberancia en relación con la posición predeterminada "centro".
Servomotor - NEMA 17:
Este motor paso a paso NEMA 17 es bipolar, tiene un ángulo de paso de 1.8º (200 pasos por vuelta) y cada bobinado es de 1.2 A a 4 V, capaz de cargar con 3.2 kg/cm.
Driver 4988:
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 la electrónica pueda resultar dañada.
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.
CoolTerm:
Es una sencilla aplicación creada por Roger Meier que permite tener una terminal para nuestros puertos serie, su menú de configuración esta 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.
El esquema del circuito seria:
Calibración Sensor:
Los valores que puede arrojar el pin de salida son:
S0 = H, S1 = H | 500 600 kHz | |
Full scale frequency | S0 = H, S1 = L | 100 120 kHz |
S0 = L, S1 = H | 10 12 kHz |
Los cálculos para definir los rangos en los que trabaja el sensor fueron sacados, censando un único objeto de los colores correspondientes y a una distancia especifica ya que dependiendo de estas variables el sensor cambia mucho de resultados.
- Los resultados para rojo fueron los siguientes:
NUM. | RED | GREEN | BLUE | CLEAR |
1 | 4 | 4 | 20 | 5 |
2 | 7 | 17 | 20 | 5 |
3 | 4 | 17 | 20 | 5 |
4 | 3 | 3 | 21 | 5 |
5 | 4 | 14 | 21 | 5 |
6 | 7 | 17 | 20 | 4 |
7 | 3 | 6 | 20 | 5 |
8 | 5 | 18 | 21 | 5 |
9 | 7 | 17 | 20 | 5 |
10 | 7 | 17 | 20 | 5 |
- Los resultados para azul fueron los siguientes:
NUM. | RED | GREEN | BLUE | CLEAR |
1 | 38 | 27 | 14 | 7 |
2 | 18 | 27 | 14 | 7 |
3 | 37 | 27 | 15 | 7 |
4 | 3 | 27 | 15 | 8 |
5 | 3 | 27 | 14 | 7 |
6 | 37 | 27 | 14 | 8 |
7 | 38 | 27 | 15 | 7 |
8 | 28 | 27 | 14 | 7 |
9 | 38 | 27 | 14 | 7 |
10 | 26 | 27 | 15 | 7 |
- Los resultados para verde fueron los siguientes:
NUM. | RED | GREEN | BLUE | CLEAR |
1 | 4 | 13 | 17 | 5 |
2 | 18 | 13 | 17 | 5 |
3 | 23 | 14 | 17 | 6 |
4 | 23 | 14 | 18 | 6 |
5 | 22 | 14 | 17 | 5 |
6 | 24 | 14 | 17 | 5 |
7 | 24 | 14 | 17 | 6 |
8 | 19 | 14 | 18 | 5 |
9 | 4 | 14 | 17 | 5 |
10 | 15 | 14 | 17 | 6 |
Con estos resultados se sacan promedios para crear rangos, en vista que casi todos los colores rondan de 1 a 30, estos resultados se multiplicaran por un numerador diferente para cada color y así crear rangos mas amplios.
Los rangos quedaran definidos de la siguiente manera como:
RANGO | COLOR |
6-9 | Rojo |
45-60 | Azul |
72-90 | Verde |
10-30 | Sin Filtro |
90-120 | Amarillo |
Y los multiplicadores de cada color para crear rangos mas altos:
COLOR | MULTIPLICADOR |
Sin Filtro | 1 |
Rojo | 1 |
Azul | 4 |
Verde | 6 |
Amarillo | 10 |
Calibración Joystick:
La calibración del joystick análogo inicia teniendo en cuenta que solo se tomaran los ejes "X" positivos y negativos, "Y" positivo y negativo cada uno con una diferencia de 90° entre si. Por ende, se conectaran los pines de los ejes de este mas sus pines de alimentación (5 Voltios y GND) a la tarjeta núcleo, y conectarla a la interfaz de Coolterm, esto para poder observar el comportamiento del voltaje dependiendo del eje que se este trabajando.
A la tarjeta se le inserto un programa pre diseñado para poder imprimir los valores del voltaje convertidos de DC a AC, para hacer un muestreo de valores de 0 a 1. Los resultados fueron:
Posición Inicial | X - Positivo | X - Negativo | Y - Positivo | Y - Negativo |
0.739 X - 0.778 Y | 0.963 X - 0.769 Y | 0.142 X - 0.771 Y | 0.745 X - 0.856 Y | 0.760 X - 0.055 Y |
0.747 X - 0.769 Y | 0.990 X - 0.789 Y | 0.100 X - 0.788 Y | 0.756 X - 0.890 Y | 0.756 X - 0.111 Y |
0.759 X - 0.781 Y | 0.957 X - 0.775 Y | 0.099 X - 0.766 Y | 0.749 X - 0.963 Y | 0.744 X - 0.167 Y |
0.752 X - 0.785 Y | 0.949 X - 0.772 Y | 0.196 X - 0.791 Y | 0.740 X - 0.876 Y | 0.749 X - 0.145 Y |
0.746 X - 0.762 Y | 0.968 X - 0.785 Y | 0.156 X - 0.784 Y | 0.760 X - 0.815 Y | 0.752 X - 0.203 Y |
0.744 X - 0.767 Y | 0.979 X - 0.788 Y | 0.179 X - 0.773 Y | 0.753 X - 0.907 Y | 0.766 X - 0.142 Y |
0.738 X - 0.773 Y | 0.991 X - 0.762 Y | 0.123 X - 0.769 Y | 0.744 X - 0.880 Y | 0.742 X - 0.088 Y |
Haciendo un promedio de los datos observados, podemos ver que los valores que toma cada eje serian:
Ejes | Posición Inicial | X - Positivo | X - Negativo | Y - Positivo | Y - Negativo |
X | 0.74 < X < 0.76 | 0.96 < X < 1 | 0 < X < 0.2 | 0.74 < X < 0.76 | 0.74 < X < 0.76 |
Y | 0.77 < Y < 0.79 | 0.77 < Y < 0.79 | 0.77 < Y < 0.79 | 0.92 < Y < 1 | 0 < Y < 0.15 |
En vista de que los valores que toma el programa entre la posición inicial y los ejes positivos de "Y" y "X", se magnifican los datos poniéndoles multiplicadores, que serian:
Posición Inicial | X - Positivo | X - Negativo | Y - Positivo | Y - Negativo |
*100 | *50 | *100 | *50 | *100 |
Con esto podemos saber como se comporta el joystick y se podrá acoplar al servomotor fácilmente.
Código¶
- Se comienza llamando a scolor_TCS3200.h, que contiene los pines del sensor y buzzer definidos con los puertos de la tarjeta núcleo:
#include "scolor_TCS3200.h"
- Se definen la tele-comandos que permite el arranque del programa y los parámetros con los que trabajara el sistema:
#define INITELE 0xFF #define Sensor_color 0x00 #define tono_1 0x01 #define tono_2 0x02 #define tono_3 0x03 #define tono_4 0x04 #define velocity_1 1200 #define velocity_2 1000 #define velocity_3 800 #define DO 130 #define RE 150 #define MI 160 #define FA 180 #define SO 200
- Se habilita la comunicación serial:
Serial command(USBTX, USBRX);
- Se definen los pines de conexión:
// definicion pines S0, S1, S2, S3, OUT scolor_TCS3200 scolor(PA_8, PB_10, PB_4, PB_5, PB_3); PwmOut mybuzzer(PA_10);//D7 D6 D5 D4 D3 //D2 DigitalOut stepper_step(PA_7);//D11 DigitalOut steppeer_dir(PA_6);//D12 DigitalOut stepper2_step(PC_7);//D9 DigitalOut steppeer2_dir(PA_9);//D8 AnalogIn X_pin(A0);//A0 AnalogIn Y_pin(A1);//A1
- Se definen las funciones del programa:
// Definición de las funciones void setup_uart(); void leer_datos(); void leer_joystick(); void leer_color(); void buzzer_1(); void buzzer_2(); void buzzer_3(); void buzzer_4(); void mover_steper_nema(); void marcha_adelante(); void marcha_atras(); void girar_derecha(); void girar_izquierda();
- Definición de variables globales:
// Variables globales uint8_t tono; // variable almacena la frecuencia del buzzer uint8_t parametro_1; // varable almacena los tiempos del buzzer leer_datos() uint8_t TC; int velocidad = 1000; // variable que almacena los telecomandos float meas_coordenadax; float meas_coordenaday;
- Se especifican los casos en los que el programa va a trabajar dependiendo del tele-comando propuesto:
int main(){ setup_uart(); while(1){ if (command.readable() == 1){ leer_datos(); switch(TC){ case 0x00: leer_color(); break; case 0x01: buzzer_1() ; break; case 0x02: buzzer_2(); break; case 0x03: buzzer_3(); break; case 0x04: buzzer_4(); break; case 0x05: marcha_adelante(); break; case 0x06: marcha_atras(); break; case 0x07: girar_derecha(); break; case 0x08: girar_izquierda(); break; case 0x09: switch(parametro_1){ case 0x01: velocidad = velocity_1; break; case 0x02: velocidad = velocity_2; break; case 0x03: velocidad = velocity_3; break;} break; case 0x0A: while(1){ leer_joystick(); mover_steper_nema(); if (command.readable() == 1){ break;}} break; default: break; return; } } } }
- Tasa de baudios para la comunicación serial:
void setup_uart(){ command.baud(115200); }
- Se leen los datos enviados desde Coolterm con los tele-comandos especificados por el usuario y los parámetros (Velocidad o tiempo según el caso) que lo acompañan :
void leer_datos(){ while(command.getc()!= INITELE); (TC=command.getc()); (parametro_1=command.getc()); }
- El programa que lee los pines análogos del joystick se pondrá desde un comienzo:
void leer_joystick(){ meas_coordenadax = X_pin.read(); meas_coordenaday = Y_pin.read(); }
- Desglosando la parte de lectura de color empezamos con definir las variables según el color que necesitamos, teniendo en cuenta que para leer el color amarillo se necesita activar los fotodiodos en conjunto de verde y azul:
void leer_color(){ long red = scolor.ReadRed(); long blue = scolor.ReadBlue(); long green = scolor.ReadGreen(); long clear = scolor.ReadClear(); long yellow= scolor.ReadBlue(); scolor.ReadGreen(); }
- Estas lineas permiten maximizar las variables a rangos mas altos debido a que la señal de salida del sensor toma rangos pequeños, así que debemos multiplicar la salida para mas adelante darle rangos mas robustos para cancelar el margen de error:
blue*=4; green*=6; clear*=1; yellow*=10;
- Se define como va a trabajar el sensor cuando la lectura arroje una frecuencia en el rango propuesto anteriormente para el color "Rojo" (Esto se debe hacer con cada color excepto con la parte de "Sin Filtro"):
if(red>=6 && red<=9){ printf ("FE01 \n", red);} else if (blue>=45 && blue<=60){ printf("FE02 \n", blue);} else if (green>=72 && green<=90){ printf("FE03 \n", green);} else if (clear>=10 && clear<=30){ printf("FE05 \n", clear);} else if (yellow>=90 && yellow<=120){ printf("FE04 \n", yellow);}
- La siguiente parte del código muestra la función que debe desempeñar el buzzer en sus respectivos casos, según el tele-comando enviado:
void buzzer_1(){ //while(command.getc()!= tono_1); mybuzzer.period_us(SO); mybuzzer.write(0.5); wait(parametro); mybuzzer.write(0);} void buzzer_2(){ //while(command.getc()!= tono_2); mybuzzer.period_us(DO); mybuzzer.write(0.9); wait(parametro); mybuzzer.write(0);} void buzzer_3(){ // while(command.getc()!= tono_3); mybuzzer.write(0.8); mybuzzer.period_us(RE); mybuzzer.write(0.6); wait(parametro); mybuzzer.write(0); } void buzzer_4(){ // while(command.getc()!= tono_4); mybuzzer.write(0); mybuzzer.period_us(MI); mybuzzer.write(0.7); wait(parametro); mybuzzer.write(0); }
- Para el movimiento del carro con tele-comandos se haría con el siguiente programa donde indica la marcha hacia adelante o reversa del carro; aparte, se muestra como hacer los giros en 90° hacia la izquierda o derecha según sea el caso, también, se podrá cambiar la velocidad agregando un cuarto tele-comando:
////////////////////////Paso por telecomando////////////////////////// void marcha_adelante(){ steppeer_dir = 0; steppeer2_dir =1; //////////////Velocidad predeterminada////////////// for(int x=0; x < parametro_1; x++){ for(int x=0; x < 200; x++){ stepper_step=1; stepper2_step=1; wait_us(velocidad); stepper_step=0; stepper2_step=0; wait_us(velocidad);}} } void marcha_atras(){ steppeer_dir = 1; steppeer2_dir =0; ///////////////Velocidad predeterminada//////////////// for(int x=0; x < parametro_1; x++){ for(int x=0; x < 200; x++){ stepper_step=1; stepper2_step=1; wait_us(velocidad); stepper_step=0; stepper2_step=0; wait_us(velocidad);}}} void girar_derecha(){ steppeer_dir = 1; steppeer2_dir =1; for(int x=0; x<200; x++){ stepper_step= 1; stepper2_step= 1; wait_us(1000); stepper_step= 0; stepper2_step= 0; wait_us(1000); } } void girar_izquierda(){ steppeer_dir = 0; steppeer2_dir =0; for(int x=0; x<200; x++){ stepper_step= 1; stepper2_step= 1; wait_us(1000); stepper_step= 0 ; stepper2_step= 0; wait_us(1000); } }
- El manejo del sistema desde el joystick análogo se inicia desde los tele-comandos definidos anteriormente y con la calibración estipulada, ademas, se movería en las direcciones indicadas por medio del siguiente programa:
void mover_steper_nema(){ float x = meas_coordenadax*100; // Read the analog input value (value from 0.0 to 1.0 = full ADC conversion range) float y = meas_coordenaday*500; if (parametro_1 == 01){ //Estatico if(x>=74 && x<=76 && y>=390 && y<=394){ stepper_step=0; stepper2_step=0; } //Y positivo marcha adelante else if (x >= 75 && x <= 76 && y >= 421 && y <= 500) { steppeer_dir = 0; steppeer2_dir = 1; for(int i=0; i<200; i++) { stepper_step=1; stepper2_step=1; wait_us(1000); stepper_step=0; stepper2_step=0; wait_us(1000); } } //y negativo marcha atras else if(x >= 74 && x <= 76 && y >= 0 && y <= 10) { steppeer_dir = 1; steppeer2_dir= 0; for(int i=0; i<200; i++) { stepper_step=1; stepper2_step=1; wait_us(1000); stepper_step=0; stepper2_step=0; wait_us(1000); } } //////////////x positivo izquierda else if(x==100 && y>=387 && y<=389){ steppeer_dir = 0; steppeer2_dir= 0; for(int i=0; i<200; i++) { stepper_step=1; stepper2_step=1; wait_us(1000); stepper_step=0; stepper2_step=0; wait_us(1000); } } ////////////x negativo derecha else if (x>=0 && x<=20 && y>=387 && y<=413){ steppeer_dir = 1; steppeer2_dir= 1; for(int i=0; i<200; i++) { stepper_step=1; stepper2_step=1; wait_us(1000); stepper_step=0; stepper2_step=0; wait_us(1000); } } } else if (parametro_1 == 02){ stepper_step=0; stepper2_step=0; } }
MANUAL DE USUARIO¶
Este fragmento del articulo explica los pasos a seguir al cliente para que de marcha al sistema Sensor & Buzzer, teniendo en cuenta que algunos pasos tienen una explicación mas en profundidad en el Manual técnico.
Los pasos a seguir son:
1. Conectar la tarjeta de desarrollo Núcleo STM F411RE, al puerto USB del PC.
2. Descargar el programa “Carro”, a la tarjeta Núcleo STM F411RE.
3. Abrir el programa “CoolTerm” en el PC.
4. Abrir “Options” y determinar el puerto que varía según el dispositivo, además, definimos el budrate o la velocidad de la CPU que será de “115200”.
5. Luego damos click en “Connect” y luego en “Clear Data”, para inicializar el programa.
6. Luego damos “CTRL+T”, se abrirá la ventanilla que permite enviar el tele-comando y damos clic en "HEX" (Hexadecimal), que indica el tipo de carácter que se va a enviar.
7. Si se quiere que el sensor se encienda y detecte los colores se escribirá el comando: FF 00 00
8. Después se hará click en "Send", esto se hará cada vez que se quiera sensar algo nuevo:
9. En la pantalla de CoolTerm se imprimirá un código en hexadecimal que indica el color censado o sin filtro.
La siguiente tabla indica cada comando impreso con su definición:
Color | Telemetria |
Rojo | FE 01 |
Azul | FE 02 |
Verde | FE 03 |
Amarillo | FE 04 |
Sin Filtro | FE 05 |
10. Para activar el buzzer también se introduce un nuevo tele-comando en el panel, y luego de hacer click en "Send" el buzzer sonara con un tono y tiempo especifico.
La siguiente tabla indica los tele-comandos que necesita el sistema para que suene el buzzer:
Tele-Comando | Parámetro (Tiempo) | Frecuencia |
FF 01 | 01 - C8 | SO |
FF 02 | 01 - C8 | DO |
FF 03 | 01 - C8 | RE |
FF 04 | 01 - C8 | MI |
- El parámetro (tiempo) se refiere a que se puede poner desde 01 hasta C8 (200 en decimales) en hexadecimal para poner el tiempo de duración del sonido.
11. Los comandos para el movimiento del carro desde el PC, dependerá de que movimiento exacto quiera que ejecute el sistema.
La siguiente tabla explica los movimientos del carro de acuerdo a sus tele-comandos:
Tele-Comando | Parámetro (Vueltas) | Movimiento del carro |
FF 05 | 01 - C8 | Adelante |
FF 06 | 01 - C8 | Reversa |
FF 07 | 00 | Giro 90° Izquierda |
FF 08 | 00 | Giro 90° Derecha |
- El parámetro (vueltas) se refiere a que se puede poner desde 01 hasta C8 (200 en decimales) en hexadecimal para poner la cantidad de vueltas que se moverán las llantas del carro.
12. Para variar la velocidad del movimiento del carro, se escribirá FF 09 con el parámetro dependiendo de la velocidad que se quiera:
Parámetro | Velocidad |
01 | Baja |
02 | Media |
03 | Alta |
- Luego se pondrá el tele-comando con el movimiento que se quiera hacer ya sea hacia adelante o en reversa:
13. La activación del joystick dependerá del siguiente tele-comando:
Tele-Comando | Parámetro (Activación) | Acción |
FF 0A | 01 | Activa el movimiento del carro por el joystick |
FF 0A | 02 | Desactiva el movimiento por medio del joystick |
- Si se activa el joystick solo se podrá manejar el carro por medio del joystick y solo responderá al comando que cancele su activación.
- Si se desactiva el joystick solo se podrá manejar el carro por medio de los tele-comandos.