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)

MBED

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.

Sensor

Los pines de conexión están repartidos de la siguiente forma:

S0S1Escala de la frecuencia de salidaS2S3Tipo Fotodiodo
HH100%HHVerde
HL20%HLSin filtro
LH2%LHAzul
LLPower DownLLRojo

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.

Buzzer

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".

Joystick

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.

Servomotor

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.

Driver

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.

Pantalla

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.

Coolterm3

El esquema del circuito seria:

Circuito

Calibración Sensor:

Los valores que puede arrojar el pin de salida son:

S0 = H, S1 = H500 600 kHz
Full scale frequencyS0 = H, S1 = L100 120 kHz
S0 = L, S1 = H10 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.REDGREENBLUECLEAR
144205
2717205
3417205
433215
5414215
6717204
736205
8518215
9717205
10717205
  • Los resultados para azul fueron los siguientes:
NUM.REDGREENBLUECLEAR
13827147
21827147
33727157
4327158
5327147
63727148
73827157
82827147
93827147
102627157
  • Los resultados para verde fueron los siguientes:
NUM.REDGREENBLUECLEAR
1413175
21813175
32314176
42314186
52214175
62414175
72414176
81914185
9414175
101514176

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:

RANGOCOLOR
6-9Rojo
45-60Azul
72-90Verde
10-30Sin Filtro
90-120Amarillo

Y los multiplicadores de cada color para crear rangos mas altos:

COLORMULTIPLICADOR
Sin Filtro1
Rojo1
Azul4
Verde6
Amarillo10

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 InicialX - PositivoX - NegativoY - PositivoY - Negativo
0.739 X - 0.778 Y0.963 X - 0.769 Y0.142 X - 0.771 Y0.745 X - 0.856 Y0.760 X - 0.055 Y
0.747 X - 0.769 Y0.990 X - 0.789 Y0.100 X - 0.788 Y0.756 X - 0.890 Y0.756 X - 0.111 Y
0.759 X - 0.781 Y0.957 X - 0.775 Y0.099 X - 0.766 Y0.749 X - 0.963 Y0.744 X - 0.167 Y
0.752 X - 0.785 Y0.949 X - 0.772 Y0.196 X - 0.791 Y0.740 X - 0.876 Y0.749 X - 0.145 Y
0.746 X - 0.762 Y0.968 X - 0.785 Y0.156 X - 0.784 Y0.760 X - 0.815 Y0.752 X - 0.203 Y
0.744 X - 0.767 Y0.979 X - 0.788 Y0.179 X - 0.773 Y0.753 X - 0.907 Y0.766 X - 0.142 Y
0.738 X - 0.773 Y0.991 X - 0.762 Y0.123 X - 0.769 Y0.744 X - 0.880 Y0.742 X - 0.088 Y

Haciendo un promedio de los datos observados, podemos ver que los valores que toma cada eje serian:

EjesPosición InicialX - PositivoX - NegativoY - PositivoY - Negativo
X0.74 < X < 0.760.96 < X < 10 < X < 0.20.74 < X < 0.760.74 < X < 0.76
Y0.77 < Y < 0.790.77 < Y < 0.790.77 < Y < 0.790.92 < Y < 10 < 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 InicialX - PositivoX - NegativoY - PositivoY - 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”.

Coolterm1

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:

ColorTelemetria
RojoFE 01
AzulFE 02
VerdeFE 03
AmarilloFE 04
Sin FiltroFE 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.

Coolterm2

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-ComandoParámetro (Tiempo)Frecuencia
FF 0101 - C8SO
FF 0201 - C8DO
FF 0301 - C8RE
FF 0401 - C8MI
  • 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-ComandoParámetro (Vueltas) Movimiento del carro
FF 0501 - C8Adelante
FF 0601 - C8Reversa
FF 0700Giro 90° Izquierda
FF 0800Giro 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ámetroVelocidad
01Baja
02Media
03Alta
  • 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-ComandoParámetro (Activación)Acción
FF 0A01Activa el movimiento del carro por el joystick
FF 0A02Desactiva 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.

All wikipages