Carro por comando de voz
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.
Pantalla táctil a TFT de 2.8:
Es una pantalla táctil a TFT de 2.8’’ TJCTM24024, de 240x320 pixeles de resolución, el modulo tiene integrado un controlador ILI9341 para manejar el LCD y un controlador táctil XPT2046 para el Touch. El módulo dispone también de una ranura de conexión para una tarjeta SD, tanto el LCD, el Touch y la SD se controlan por SPI.
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 (3.3 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
- Ademas, se definen las características (Ancho, alto y comando para los colores) de la pantalla TFT:
#define TFT_WIDTH 320 #define TFT_HEIGHT 240 #define TFT_BLUE 0x1F00 #define TFT_RED 0x00F8 #define TFT_GREEN 0xE007 #define TFT_YELLOW 0xE0FF
- 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 SPI spi(PC_12, PC_11, PC_10); DigitalOut cs(PC_9); // TFT chipselect pin DigitalOut dc(PB_9); // TFT data command select pin DigitalOut rst(PB_8); // TFT reset pin
- Ademas, se definen las interrupciones que se utilizaran en el programa entre las cuales se tienen en cuenta 3 temporizadores y 1 interrupción por botón:
Ticker tk1; Timeout stop; InterruptIn button1(USER_BUTTON); Timeout button1_timeout; // Used for debouncing
- Se definen las funciones del programa:
// definición de las funciones void task1(void); 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(); void buzzeroff(); void button1_enabled_cb(void) { button1_enabled = true; }
- Definición de variables globales:
// Variables globales uint8_t parametro; uint8_t TC; uint8_t vueltas; float meas_coordenadax; float meas_coordenaday; int velocidad = 1000;
- Para el uso de la pantalla TFT se deben definir algunas funciones de forma inicial para la activación de esta, empezando por la función write, la cual inicia la escritura en la pantalla:
void write_cmd(uint8_t cmd) { dc = 0; spi.write(cmd); }
- Siguiente se inicia el programa de Reset, el cual permite un reinicio a lo escrito en la pantalla anteriormente:
void tft_reset() { wait_ms(200); cs = 1; dc = 1; rst = 1; wait_ms(200); rst = 0; wait_us(10); rst = 1; wait_ms(120); cs = 0; wait_ms(10); write_cmd(0x3A); // Pixel Format write_data(0x55); // 16bit Color write_cmd(0xB1); // Frame Control write_data(0); write_data(0x1f); write_cmd(0x36); // Memory Access Control write_data(0xE8); // MY MX MV BGR write_cmd(0x11); // Sleep Out wait_ms(5); write_cmd(0x29); // Display On }
- Luego se inicia la configuración de la pantalla (Set window):
void tft_set_window(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) { write_cmd(0x2A); // Column Address Set write_data(x0 >> 8); write_data(x0); write_data(x1 >> 8); write_data(x1); write_cmd(0x2B); // Page Address Set write_data(y0 >> 8); write_data(y0); write_data(y1 >> 8); write_data(y1); write_cmd(0x2C); // Memory Write wait_us(20); dc = 1; }
- Por ultimo para poder iniciar la pantalla define un estado inicial o Clear en el que operara la pantalla:
void tft_clear(uint16_t color) { tft_set_window(0, 0, TFT_WIDTH, TFT_HEIGHT); for (int i = 0; i < TFT_WIDTH * TFT_HEIGHT; ++i) { spi.write(color & 0xff); spi.write(color >> 8); } }
- Otro programa que se debe iniciar antes del int main, es el que lee la interrupción del botón, este sub programa atiende el llamado de la interrupción y activa las variables para dirigir la interrupción:
void button1_onpressed_cb(void) { if (button1_enabled) { // Disabled while the button is bouncing button1_enabled = false; button1_pressed = true; // To be read by the main loop button1_timeout.attach(callback(button1_enabled_cb), 0.3); // Debounce time 300 ms } }
- Se especifican los casos en los que el programa va a trabajar dependiendo del tele-comando propuesto, se puede desarrollar cada uno de estos programas de manera independiente pero se tendrá un timer trabajando constantemente para leer cada 0.5 segundos un color llamando en este lapso de tiempo el programa ""Leer color"", ademas se adjunta una linea Redeable, que permite leer constantemente si hay un dato por leer en el serial:
int main(){ spi.frequency(45000000); button1.fall(callback(button1_onpressed_cb)); tk1.attach(&leer_color, 0.5); setup_uart(); while(1){ if (command.readable() == 1){ leer_datos(); switch(TC){ case 0x00: spi.frequency(45000000); tft_reset(); 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(); if (command.readable() == 1){ break;} break; case 0x06: marcha_atras(); break; case 0x07: girar_derecha(); break; case 0x08: girar_izquierda(); break; case 0x09: switch (parametro){ 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, ademas dependiendo del color este se vera en la pantalla TFT:
if(red>=6 && red<=9){ command.putc(0xFE); command.putc(0x01); tft_clear(TFT_RED);} else if (blue>=45 && blue<=60){ command.putc(0xFE); command.putc(0x02); tft_clear(TFT_BLUE);} else if (green>=72 && green<=90){ command.putc(0xFE); command.putc(0x03); tft_clear(TFT_GREEN);} else if (clear>=76 && clear<=100 && blue>=45 && blue<=60 && red>=6 && red<=9 && green>=72 && green<=90){ command.putc(0xFE); command.putc(0x05);} else if (yellow>=10 && yellow<=30){ command.putc(0xFE); command.putc(0x04); tft_clear(TFT_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. Para poder generar la interrupción del buzzer se agrega el llamado del temporizador, que deshabilita el proceso, llamando el programa ""Buzzeroff" y así poder ejecutar otro programa:
void buzzer_1(){ //while(command.getc()!= tono_1); mybuzzer.period_us(SO); mybuzzer.write(0.5); stop.attach(&buzzeroff, parametro);} void buzzer_2(){ //while(command.getc()!= tono_2); mybuzzer.period_us(DO); mybuzzer.write(0.9); stop.attach(&buzzeroff, parametro);} void buzzer_3(){ // while(command.getc()!= tono_3); mybuzzer.write(0.8); mybuzzer.period_us(RE); mybuzzer.write(0.6); stop.attach(&buzzeroff, parametro);} void buzzer_4(){ // while(command.getc()!= tono_3); mybuzzer.write(0); mybuzzer.period_us(MI); mybuzzer.write(0.7); stop.attach(&buzzeroff, parametro);} void buzzeroff (){ 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, para poder generar la interrupción desde el botón del joystick de este proceso se integraron unas lineas que llaman la interrupción del proceso FOR; esto se hará con el movimiento hacia adelante y reversa:
////////////////////////Paso por telecomando////////////////////////// void marcha_adelante(){ steppeer_dir = 0; steppeer2_dir =1; void marcha_adelante(){ steppeer_dir = 0; steppeer2_dir =1; for(int x=0; x < parametro; x++){ for(int x1=0; x1 < 200; x1++){ stepper_step=1; stepper2_step=1; wait_us(velocidad); if (button1_pressed){ button1_pressed = false; x1 = 200; parametro = 0; } else { stepper_step=0; stepper2_step=0; wait_us(velocidad); } } } } void marcha_atras(){ steppeer_dir = 1; steppeer2_dir =0; for(int x=0; x < parametro; x++){ for(int x1=0; x1 < 200; x1++){ stepper_step=1; stepper2_step=1; wait_us(velocidad); if (button1_pressed){ button1_pressed = false; x1 = 200; parametro = 0; } else { stepper_step=0; stepper2_step=0; wait_us(velocidad); } } } }
- El otro programa de los motores son los giros hacia la izquierda y derecha en 90° del carro:
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>=48 && x<=52 && y>=259 && y<=265){ stepper_step=0; stepper2_step=0; } //Y positivo marcha adelante else if (x >= 49 && x <= 52 && y >= 495 && y <= 502) { 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 >=49 && x <= 52 && y >= 4 && y <= 9) { 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 >= 95 && x <=102 && y>= 260 && y<= 265){ 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>= 1 && x<= 4 && y>= 259 && y<= 265){ 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. La pantalla la pondremos en HEX, para que nos pueda mostrar los datos en hexadecimal del sensor.
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 |
- El color también se vera reflejado en la pantalla TFT.
7. 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.
8. 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.
9. 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.
- La operación se podrá terminar en cualquier momento oprimiendo el botón ubicado en el joystick, después de oprimirlo podrá volver a llamar cualquier operación de manera normal.
10. 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:
11. 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.