Como propósito este manual tiene la finalidad de dar a entender a la persona que vaya a manipular el carro, entendiendo su funcionalidad. En el manual técnico se explica de forma detallada la forma que trabaja el carro en cuanto a software y hardware desarrollado mediante la plataforma de MBED. Y en el manual de usuario en donde se encuentran las instrucciones básicas de conexión para poner en marcha el carro teniendo en cuenta como funciona el sistema.

Manual técnico

-Especificación de los componentes a utilizar.

Tarjeta STM32F411

Es un sistema embebido fabricado por la empresa ST microlelectronics ,esta basada en un micro controlador ARM cortex m4 de 32 bits el cual maneja una velocidad de procesamiento de 100MHz,512 Kbytes de memoria flash junto a 128-Kbytes de memoria RAM. Entre los componentes que conforman la STM32-NUCLEO F411RET6 se puede encontrar 64 puertos destinados a la vinculación de diferentes perifericos, tales como servomotores, motores paso a paso (steppers), lLEDs ,entre otros periféricos para poder desarrollar proyectos y soluciones enfocados a la robótica.

Puertos de conexión:

USART (Transmisores receptores síncronos / asíncronos universales)

Los dispositivos incorporan tres transmisores receptores síncronos / asíncronos universales (USART1, USART2 y USART6). Estas tres interfaces proporcionan comunicación asíncrona, soporte IrDA SIR ENDEC, Modo de comunicación multiprocesador, modo de comunicación semidúplex de un solo cable y tienen capacidad LIN Master / Slave. Las interfaces USART1 y USART6 son capaces de comunicarse a velocidades de hasta 12.5 Mbit / s. La interfaz USART2 se comunica hasta 6,25 bit /s. USART1 y USART2 también proporcionan administración de hardware de las señales CTS y RTS, estas interfaces pueden ser servidas por el controlador DMA.

Periféricos incluidos en la tarjeta:

Sensor de color TCS3200

Es un sensor óptico fabricado por la empresa TAOS (Texas Advanced Optoelectronic Solutions) controlado mediante PWM (Pulse Width Modulation) ,el cual su principal funcionamiento es detectar diferentes tipos de color realizando conversiones de alta resolución de intensidad lumínica a frecuencia. este sensor ,completamente programable,maneja un margen de error de no linealidad de 0.2% a 50 kHz e internamente está conformado por una matriz de (4*6) foto-diodos los cuales están distribuidos en 4 colores base (6 diodos con filtros rojos,6 con filtros verdes ,6 con filtros azules y 6 sin filtro) ;los 4 tipos de colores son interdigitados para disminuir el efecto de no-uniformidad o irradiación incidente.

Diagrama de conexión:

Diagrama de funcionamiento:

• Calibración del sensor de color:*

Según los datos que puede arrojar el pin de salida se puede deducir que:

S0=H,S1=H 500 600 kHz Full scale frequency S0=H,S1=L 100 120 kHz S0=L,S1=L 10 12 kHz

• Rango en el que se define el color*

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

Multiplicadores de color para rangos altos:

*COLOR MULTIPLICADOR Sin Filtro 1 Rojo 1 Azul 1 Verde 1 Amarillo* 1

La configuración del sensor se realiza según el pin de salida de la señal con un periodo del 50%, es necesario la calibración del sensor según la 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".

• Calibración del Joystick según voltaje de 0-1V *

• Mediante estos datos se obtiene el promedio en cada eje según su posición*

Motor NEMA 17:

es un dispositivo electromecánico que convierte una serie de impulsos eléctricos en desplazamientos angulares discretos, lo que significa que es capaz de girar una cantidad de grados (paso o medio paso) dependiendo de sus entradas de control. El motor paso a paso se comporta de la misma manera que un conversor digital-analógico (D/A) y puede también leer impulsos procedentes de sistemas digitales. Este motor presenta las ventajas de tener precisión y repetitividad en cuanto al posicionamiento.

Esta clase de motores tienen un comportamiento similar a un conversor análogo-digital, lo que significa que puede ser controlado por impulsos procedentes de sistemas digitales; también tienen varias ventajas como su precisión y repetitividad a lo que se refiere a posicionamiento, lo cual se utilizan para diferentes aplicaciones (impresoras digitales, robots, procesos de automatización etc.); Se dividen en 3 clases (rotor de imán permanente, hibrido y de reluctancia variable) y 2 tipos (unipolares y bipolares) Los motores utilizados para este prototipo fueron los motores nema 17, siendo estos motores BIPOLARES, dichos motores, se caracterizan por tener 4 salidas y su funcionamiento se puede representar en la siguiente tabla:

Driver 4988:

Estos controladores permiten manejar los altos voltajes e intensidades que requieren estos motores, limitar la corriente que circula por el motor y proporcionar protección para evitar que la electrónica pueda resultar dañada.

Para controlarlo se requiere dos salidas digitales, una para indicar el sentido de giro y otra para comunicar el avance del motor. Además permite realizar microstepping, una técnica para conseguir precisiones superiores al paso nominal del motor.

Conversor analogo digital (ADC)

CoolTerm:

1. Abrir el software CoolTerm.

2. Una vez abierto el Software, debe asegurarse de que la tarjeta STM32F411 esté conectada; Se podrá verificar si ha sido correctamente conectada en la parte inferior.

3. Además también será necesario revisar en options y asegurarse de que la velocidad de transmisión o baud rate sea la misma en la tarjeta y en el programa.

Una vez elegida la opción 115200 es necesario guardar los cambios con el botón ok

4. Una vez ya configuradas las opciones es necesario para enviar datos desde :

Connection>Send String

Y desplegará una nueva ventana desde la cual se podrán enviar datos en lenguaje hexa-decimal.

Conexión del circuito:

Interrupciones:

Definición: hace referencia a detener o impedir la continuidad de un proceso, una acción, un asunto, etc.

En la que en este caso se detiene la acción que el carro está realizando en el momento y empieza a hacer otra. Una vez se detiene en este caso es posible nuevamente mandar un tele-comando.

¿Cómo ejecutar las funciones del carro?

Nota: C8 en hexadecimal es igual a 200 en decimal.

1. El carro permanentemente está leyendo que color tiene al frente, por lo que siempre aparecerá cada determinado tiempo un color diferente según su lectura; para determinar que color está leyendo es necesario saber las telemetrias que envía según el color:

2. Para activar el buzzer según una frecuencia determinada (DO-RE-MI-FA) y posteriormente digitar la cantidad de tiempo en hexadecimal que desea que suene el pitido.

Al oprimir "Send" se enviará y por consiguiente sonará el tono y la cantidad de tiempo deseado.

La siguiente tabla indica los telecomandos, parametros y frecuencia que necesita el sistema para que el buzzer funcione:

Nota: El parametro tiempo tiene una restricción desde 01-C8 (200) en tiempo dura el sonido.

3. Los comandos para poner en marcha el carro desde la salida de Coolterm dependen de la dirección que se le quiera enviar además del número de pasos según la dirección (adelante y atrás) a la que se quiera ir. En la siguiente tabla se representa como debe ingresarse el tele-comando el parámetro y el tipo de movimiento que va a tener el carro

4. La velocidad también es posible cambiarla según el parámetro FF09 En el que se brinda la posibilidad de variarla en tres diferentes (baja, media y alta): Tal como se explica en la siguiente tabla:

5. Por último la activación y des-activación del Joystick; en la que se podrá girar, avanzar, retroceder en caso de que se active o no este parámetro según la elección del usuario.

En caso de que el joystick este desactivado solo podrá manejarse desde la parte de telecomandos y en caso de que este activado no recibirá telecomandos hasta que se desactive el parametro de activación del joystick. Para ello se explica en la siguiente tabla el parametro y la acción que realiza:

6. Para detener el movimiento del carro mientras realiza una acción enviada por un telecomando, bastará simplemente con presionar el pulsador que se encuentra en el joystick. Después de detenido el carro podrá enviar cualquier tele-comando para continuar utilizando el carro.

Código

• Se comienza llamando a scolor_TCS3200.h, que contiene los pines del sensor de color definidos en los puertos de la tarjeta núcleo:

#include "scolor_TCS3200.h"

• Cada tele-comando se define para que el programa inicie y para definir los parámetros con los que trabaja 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 2500
#define velocity_2 5000
#define velocity_3 7500
#define DO  200
#define RE  250 
#define MI  300 
#define FA  350 
#define SO  400 

• Se define la comunicación:

Serial command(USBTX, USBRX);

• Definición de puertos de conexión:

Nota: AnalogIn (Entrada analógica), DigitalOut (Salida digital)

Serial command(USBTX, USBRX);
//   definicion pines  S0,    S1,   S2,   S3,    OUT
scolor_TCS3200 scolor(PA_9, PC_7, PB_6, PA_7, PA_6);
PwmOut mybuzzer(PB_8);//D7   D6     D5    D4    D3
                //D2
DigitalOut stepper_step(PB_4);//D11
DigitalOut steppeer_dir(PB_5);//D12
DigitalOut stepper2_step(PB_10);//D9
DigitalOut steppeer2_dir(PA_8);//D8
InterruptIn B1(PC_13);
AnalogIn analog_M1(A3);
AnalogIn analog_M2(A2);
AnalogIn analog_M3(A1);
AnalogIn analog_M4(A0);

• Definicion de 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();
void pulsadorj();

• Definición de 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 = 2000;     // variable que almacena los telecomandos 
float meas_X; //para joystick 1
float meas_Y;
float meas_X2; //para joystick 2 
float meas_Y2;

• Para que el sensor de color siempre este leyendo cada determinado tiempo es importante definir esto como una variable

Ticker tk1;

• Interrupción 1 en la que siempre se imprime el color que se ha detectado (ver. funciones del carro) en hexadecimal.

B1.rise (& f_ISR_BR);
while(1){
if (command.readable() == 1){    
leer_datos();
tk1.attach(&leer_color, 0.8);   // este parametro imprime el color sensado (interrupcion 1)

• En un switch case se especifican las funciones que el carro va a realizar

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;
}

Se especifica la tasa de baudios para la comunicación serial en la UART

void setup_uart(){
command.baud(115200);}

• Para los datos que se envían mediante CoolTerm a la tarjeta debe realizarse una lectura de los tele-comandos, parámetros y tiempo que especifica el usuario

void leer_datos(){
while(command.getc()!= INITELE);
(TC=command.getc());
(parametro_1=command.getc());
}

• Los pines analógicos del joystick se inicializan para leer los datos entrantes.

void leer_joystick(){
   
   meas_X=analog_M1.read();
        meas_Y=analog_M2.read();
        meas_X2=analog_M3.read();
        meas_Y2=analog_M4.read();
}

Nota: El valor de salida es desde 0.0V hasta 1V y hace una conversión análoga a digital.

• Posteriormente para empezar la lectura del color es necesario que lea las variables según el color que mandamos y el que imprime en la pantalla. Para este caso, el color amarillo en particular, es necesario activar los foto-diodos verde y azul para leer el color.

Nota: Como se indica en la parte superior (Vease. Definición de sensor de color) el sensor solo tiene foto-diodos rojo, azul y verde por lo que es necesario hacer una mezcla para determinar un nuevo color.

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();

• Es necesario multiplicar la salida del sensor para reducir el margen de error

red*=2;
  blue*=4;
  green*=6;
  clear*=10;
  yellow*=10;

• Se define como va a trabajar el sensor cuando la lectura arroje una frecuencia en el rango propuesto para el color.

   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<=40){
   printf("FE05 \n", clear);}
   
   else if (yellow>=90 && yellow<=120){
   printf("FE04 \n", yellow);}
   }

• Según el tono (DO, RE,MI,FA) que se envía y teniendo en cuenta que anteriormente se definió el caso para cada sonido, según el tele-comando que se envía:

 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);
   }

• Nota: Para la interrupción del buzzer tono sobre tono fue necesario modificando algunas lineas y se añade la variable "buzzeroff" y la variable parametro_1 que da prioridad al nuevo comando que se le envía en cuanto a sonido.

void buzzeroff ();
uint8_t parametro_1;  // varable almacena los tiempos del buzzer 

void buzzer_2(){
   mybuzzer.period_us(RE); 
   mybuzzer.write(0.9);
   stop.attach (&buzzeroff, parametro_1);}

• Para el telecomando de movimiento del carro en donde puede ir adelante, atrás, 90° a la derecha o a la izquierda según sea el caso, también la velocidad podrá variar al igual que la definición del número de pasos (excepto los giros) que va a dar.

////////////////////////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<400; x++){
    stepper_step= 1;
    stepper2_step= 1;
    wait_us(2000);
    stepper_step= 0;
    stepper2_step= 0;
    wait_us(2000); }
    }
    
void girar_izquierda(){

    steppeer_dir = 0;
    steppeer2_dir =0;
     for(int x=0; x<400; x++){
        stepper_step= 1;
        stepper2_step= 1;
        wait_us(2000);
         stepper_step= 0 ;
        stepper2_step= 0;
        wait_us(2000); }
    }

Nota: Para la interrupción en la que los motores al estar girando adelante o atrás y al enviar otro tele-comando en el que debe ir en la dirección opuesta en el código se detiene la acción que realiza dándole un valor =0 para que se detenga y empiece a hacer el otro sentido de giro.

for(int x=0; x < parametro_1; x++){
    for(int x=0; x < 200; x++){
    stepper_step=1;
    stepper2_step=1;
    wait_us(velocidad);
    stop.attach (&buzzeroff, parametro_1);
    if (button1_pressed) { // Set when button is pressed
    button1_pressed = false;
    x = 200;
    parametro_1 = 0;
    }
    else if(marcha_atras){
        stop.attach (&buzzeroff, parametro_1);}
    else {
    stepper_step=0;
    stepper2_step=0;
    wait_us(velocidad);}}}}

• Interrupción para botón 1:

InterruptIn button1(USER_BUTTON);
volatile bool button1_pressed = false; // Used in the main loop
volatile bool button1_enabled = true; // Used for debouncing
Timeout button1_timeout; // Used for debouncing

// Enables button when bouncing is over
void button1_enabled_cb(void)
{
    button1_enabled = true;
}

// ISR handling button pressed event
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
    }
}

int main(){ setup_uart(); button1.rise(callback(button1_onpressed_cb)); Attach ISR to handle button press event

En cuanto el pulsador manda un flanco de subida, (1), se envía un comando en el que la acción que está realizando en el momento (mover motores adelante y atrás) se detiene en el instante.

<</code>>

• Por último para que el joystick pueda moverse con su calibración correspondiente en los dos diferentes ejes con el 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 manual tiene como objetivo orientar al usuario final a usar de manera sencilla el sistema de vehículo en cuanto a sus funciones respectivas, sus conexiones y comandos funcionales del mismo.

En el que usted podrá encontrar, como se indicó anteriormente, la forma más sencilla de cómo realizar las conexiones necesarias para el funcionamiento del producto.

Pasos a seguir para preparar el vehículo:

1.Conectar el sistema de desarrollo Stm32 Nucleo-F411RET6 al puerto USB de su computadora, cuando el sistema se haya conectado a su pc, usted notara que su sistema instalara los drivers correspondientes y encontrara esta notificación en su software:

2. Copiar y cargar el archivo “Vehículo detector de color” a el puerto NODE_F411RE (este puerto lo encontrara ingresando al explorador de archivos).

3.Conectar la batería para alimentar el vehículo

4. Abrir el software COOLTERM en su computadora

5.Una vez abierto el software COOLTERM, u deberá proceder a dar clic en la opción “Conectan” y dirigirse a la opción “Option”

6.Luego de haber ingresado a “Option”, dirigirse a la opción “Baudrate” y seleccionar el numero 115200y luego dar clic en el botón ok

7.Dirigirse a la opción “Conectó” y dar clic para poder conectar el vehículo con la interfaz Coolterm.

8.dirigirse de nuevo a la opción “Connection” y seleccionar la opción “Send String” o en su defecto presionar las teclas “Ctrl+T”, aparecerá un panel de comandos con 2 checkbox (ascii-Hex), seleccionar la opción “Hex”

9.una vez puesto a funcionar el vehículo, el mismo empezara a detectar colores de manera constante y arrojara en código hexadecimal los siguientes comandos:

10.para hacer funcionar el Buzzer, se debe ingresar los siguientes comandos en el panel de comandos, cada comando tendrá una frecuencia de sonido y tiempo establecidos como se puede ver en la siguiente tabla:

• 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 de cada sonido

11. si se desea dar movimiento al vehículo, se deberá que ingresar los siguientes comandos, dependiendo de cada comando, el vehículo girará, se moverá a delante o atrás. En la siguiente tabla se podrán visualizar los comandos respectivos para movimiento y sus respectivas funciones:

• Para controlar la velocidad del vehículo se deberá ingresar el comando FF09 más el parámetro 01(velocidad baja),02(velocidad media) o 03 (velocidad alta), lo que permitirá variar la velocidad del vehículo como se desee

12. Para activar/desactivar el funcionamiento del joystick, se deberá ingresar la tele comando:

Nota: el joystick cuenta con 4DOF (grados de libertad) que son adelante, atrás, izquierda y derecha Cuando el joystick está habilitado, solo, el joystick funcionara hasta que el usuario deshabilite la función desde el software coolterm

13. Una de las características del vehiculo sensor de color ,es su capacidad de funcionar en tiempo real mediante interrupciones,las cuales se encuentran distribuidas en el funcionamiento del sensor de color que permite detectar en tiempo real y de manera constante los colores predeterminados anteriormente,el joystick , el cual permite detener el vehículo durante su funcionamiento presionando el joystick y reanudar su funcionamiento ,una vez se presione el joystick de nuevo y finalmente en el cambio de comandos, el cual permite que se pueda introducir cualquier comando vía coolterm durante la ejecución de un comando preestablecido por el usuario anteriormente , es decir, luego de introducir un comando , se puede volver a introducir un nuevo comando, interrumpiendo la acción anterior y reproduciendo la acción siguiente

• Interrupciones:

• Sonido sobre sonido

Al enviar un telecomando de sonido y posteriormente enviar otro con diferente sonido, se detendrá el actual y sonará el seleccionado.

• Al pulsar el botón del centro del joystick detención de los motores

Para detener el movimiento del carro mientras realiza una acción enviada por un telecomando, bastará simplemente con presionar el pulsador que se encuentra en el joystick. Después de detenido el carro podrá enviar cualquier tele-comando para continuar utilizando el carro.

• Cambio de sentido de giro de los motores.

Si el carro marcha adelante o atrás y esta opción se desea activar, basta con mandar el tele-comando con el número de pasos a realizar inversa a la dirección actual ¡Y ya está!.