Robot controlado por voz 2WD con Arduino y servidor BitVoicer

Acerca de este proyecto

En este tutorial, voy a mostrar cómo construir un robot 2WD controlado por voz. Aunque solo estoy controlando motores de CC para mover el robot, el mismo enfoque se puede utilizar para controlar por voz motores paso a paso y servomotores, por lo que si planea construir cualquier robot controlado por voz que realice movimientos mecánicos, este tutorial puede servir como referencia para su proyecto.

Para construir este robot, básicamente necesitará un chasis de 2 ruedas, una placa Arduino, un protector de controlador de motor de CC, una licencia de servidor BitVoicer, un módulo WiFi y un micrófono preamplificado. En cuanto a los componentes, existe una gran variedad de ellos en el mercado y se pueden conseguir los mismos resultados utilizando distintas combinaciones. En el Paso 1, doy algunos detalles sobre algunos componentes usados ​​en el robot, así que si necesita cambiar algunos de ellos, simplemente busque componentes con características similares.

Se ejecutarán los siguientes procedimientos para transformar los comandos de voz en movimientos del robot:

• 1. Las ondas de audio serán capturadas y amplificadas por la placa Sparkfun Electret Breakout;
• 2. La señal amplificada se digitalizará y almacenará en búfer en el Arduino utilizando su convertidor analógico a digital (ADC);
• 3. Las muestras de audio se transmitirán al servidor BitVoicer mediante el módulo WiFi de Microchip;
• 4. BitVoicer Server procesará el flujo de audio y reconocerá el discurso que contiene;
• 5. El discurso reconocido se asignará a comandos predefinidos que se enviarán al Arduino;
• 6. El Arduino identificará el comando y definirá qué motores de CC se utilizarán, durante cuánto tiempo y a qué velocidad;
• 7. El controlador del motor se activará para proporcionar el voltaje y la corriente necesarios para mover los motores.

Lista de materiales:

• Arduino UNO:~ U $ 25.00
• Escudo del controlador de motor Pololu Dual MC33926:29,95 EE. UU.
• SparkFun XBee Shield:U $ 14.95
• Módulo Microchip RN171VX con antena:U $ 34.95
• Desglose del micrófono SparkFun Electret:U $ 7.95
• BitVoicer Server 1.0:U $ 8,90
• Chasis de coche robot 2WD:U $ 15,95
• Regulador de voltaje Texas Instruments LM1117 (TO-220):~ U $ 1.95
• Condensador electrolítico de 10μF:~ U $ 0.35
• 4 x LED:~ US 1.00
• 4 resistencias de 330 ohmios:~ U $ 0,75
• 4 pilas AA de 1,5 V:~ 2,00 EE. UU.
• Batería de 9 V:~ US 2.00
• Adaptador de conector de 9 V a barril:~ US 2.50
• Cables de puente y cables normales:~ U $ 2.00
• Tornillos y abrazadera de plástico flexible para la fijación
• Soldador y soldadura

PASO 1:Familiarización con los componentes

En este paso, proporciono información importante sobre los componentes del robot y cómo prepararlos para el montaje.

En primer lugar, el corazón del robot:un Arduino UNO R3. Aunque estoy usando un Arduino UNO, puede usar otras placas Arduino para montar su robot. Decidí usar un Arduino UNO porque es, con mucho, la placa Arduino más popular y más personas podrían reconstruir este robot. Si tiene un Arduino DUE, también puede agregar respuestas de voz a su robot como hice en este tutorial.

Para mover los motores de CC, utilicé este escudo Pololu. Es un controlador de motor dual capaz de controlar motores de 5 a 28 V CC y entregar hasta 3 A de corriente continua por motor. Aunque creo que este es un escudo muy bueno, lo que más me impresionó de los productos de Pololu es su documentación clara y detallada. Además, Pololu proporciona una biblioteca Arduino que simplifica mucho el control de los motores. Solo tienes que pasar la velocidad y dirección (valores negativos o positivos) al setSpeeds función. Si opta por utilizar otro controlador de motor de CC, preste atención a las clavijas que utiliza el controlador porque no pueden entrar en conflicto con ninguna otra clavija utilizada por el robot. El escudo Pololu utiliza los siguientes pines Arduino:digital 4, 7, 8, 9, 10 y 12; analógico 0 y 1; tierra; y 5V. El aspecto más importante aquí es que solo los pines 9 y 10 se usan como pines PWM y el temporizador utilizado para generar pulsos en estos pines no es el mismo temporizador (temporizador 2 en UNO) utilizado por la clase BVSMic de BitSophia.

Para establecer comunicación con el servidor y acceder a los servicios de BitVoicer Server, utilizo el módulo Microchip WiFi RN171VX. En este módulo destacan dos características principales:toda la comunicación se puede realizar a través del puerto serie de manera sencilla; y el módulo tiene el mismo factor de forma que la mayoría de los módulos XBee populares. En otras palabras, si ya tiene un escudo XBee, lo más probable es que no necesite comprar el escudo Sparkfun que uso en este robot.

El uso del escudo XBee con el módulo WiFi de Microchip facilitó bastante el montaje del robot. Sin embargo, he identificado un problema en esta combinación. Se sabe que trabajar con la radio es sumamente complejo y algunos lo consideran “magia vudú”. Bueno, noté que mientras el adaptador WiFi está encendido y transmitiendo datos, se produce una fuerte interferencia en la señal de audio medida por el Arduino ADC. No pude identificar con precisión la fuente de esta interferencia, pero tengo dos fuentes posibles:los consumos de corriente máxima del módulo (hasta 240 mA) no están desacoplados correctamente y comprometen el voltaje de referencia proporcionado al ADC de Arduino; o la señal emitida por la antena está siendo captada por algunos pines expuestos justo debajo del módulo. Por lo general, los fabricantes de módulos WiFi indican a los diseñadores que eviten colocar nada (incluso planos de tierra) cerca de la antena precisamente para evitar este tipo de problemas.

Para corregir el problema descrito anteriormente, soldé un regulador de voltaje de 3.3V y un capacitor electrolítico de 10μF al escudo Sparkfun para que pudieran proporcionar el voltaje de referencia al Arduino ADC. El micrófono electret Sparkfun utiliza la misma fuente de alimentación. Resolvió los problemas de volumen máximo que estaba viendo en BitVoicer Server Manager. Incluso durante los períodos de silencio, el nivel de audio llegaba a 35 (0-100) en el Monitor del servidor. Si ve que sucede lo mismo en su proyecto, investigue qué está sucediendo con la señal de audio medida por el Arduino ADC.

Decidí que también iba a usar el espacio de creación de prototipos disponible en el escudo Sparkfun para soldar algunos LED que indican el estado de algunas funcionalidades del servidor BitVoicer. En la imagen siguiente, de izquierda a derecha, los LED muestran la siguiente información:

• Indica si BitVoicer Server se está ejecutando y / o si la conexión permanece activa;
• indica si el servicio de reenvío de datos se está ejecutando;
• Indica si se ha asignado un motor de reconocimiento de voz al Arduino;
• Indica si estamos en el período de activación-palabra-activada. Este LED se enciende solo cuando se identifica la palabra de activación.

En cuanto al micrófono electret preamplificado, hay muchas opciones disponibles en el mercado:Sparkfun, Adafruit, RoboCore, Hackerstore y probablemente muchas otras. Para usar el código que estoy publicando en este tutorial, asegúrese de que el micrófono que está comprando sea analógico, que el voltaje requerido esté disponible en su placa Arduino y que la amplificación sea lo suficientemente alta (generalmente 100x para micrófonos electret) para el Arduino ADC.

El chasis 2WD utilizado en el robot es uno de los más baratos y populares de eBay. El kit completo contiene una plataforma acrílica, dos ruedas de plástico / goma, una rueda de 360º, dos motores DC con engranaje (relación 1:48), un portapilas 4xAA, dos discos codificadores de velocidad y un juego de tornillos.

PASO 2:Montaje

¡Pongámonos a trabajar! En este paso, debe montar todos los componentes en el chasis como se muestra en las imágenes a continuación.

Si no desea soldar los LED y el regulador de voltaje en el escudo XBee, puede montarlos en una placa pequeña como se muestra en la imagen a continuación. En este caso, elija una placa de pruebas de tamaño reducido para que pueda arreglarla en algún lugar del chasis sin más problemas.

En las imágenes de arriba, puedes notar que hice un soporte de alambre de hierro para sostener el micrófono. También puedes ver que pegué una tira de tela de fieltro alrededor de la rueda de 360º. Tomé estas dos medidas para intentar reducir el ruido generado por el robot y captado por el micrófono cuando el robot se está moviendo. Incluso corté un pequeño trozo de esponja para aislar los cables del micrófono del soporte. Por supuesto, no fue 100% efectivo, pero redujo un poco el ruido y mejoró la precisión del reconocimiento de voz.

PASO 3:Configuración del módulo WiFi

Como dije en el Paso 1, el módulo WiFi Microchip RN171VX se puede operar totalmente a través del puerto serie. Esto hace que la configuración del módulo sea extremadamente fácil porque todos los comandos son cadenas simples que se envían a través del puerto serie Arduino. Solo tiene que enviar una cadena que contenga "$$$" para ingresar al modo de comando, enviar los comandos y luego enviar una cadena que contenga "salir" para volver al modo de datos.

El código llamado Configuración del módulo WiFi En la parte inferior de este tutorial está el código que utilicé para configurar el módulo WiFi en mi red doméstica. Deberá cambiar las partes del código marcadas como “XXXXXX” con información de su red WiFi. Deberán cambiarse tres comandos:

• establecer wlan ssid XXXXXX :reemplace XXXXXX con el nombre de su red (SSID);
• establecer la frase wlan XXXXXX :reemplace XXXXXX con su contraseña de red;
• establecer la dirección IP XXXXXX :reemplace el XXXXXX con la dirección IP (estática) que desea configurar para su módulo WiFi.

En mi red WiFi, el método de autenticación es WPA2-PSK. Si su red utiliza un método de autenticación diferente, también tendrá que cambiar set wlan auth mando. Consulte la documentación del módulo WiFi (sección 4.3 Establecer comandos) para averiguar qué valor es el correcto para su red.

Hay un importante detalle sobre el escudo Sparkfun y su pequeño interruptor (imagen de abajo). Para cargar código al Arduino usando su interfaz USB, el interruptor debe estar en la posición DLINE. Para que Arduino envíe / reciba datos a través del módulo WiFi usando su puerto serie, el interruptor debe estar en la posición UART. Esto es necesario porque el módulo WiFi y el chip USB en el Arduino UNO usan el mismo puerto serie en el microcontrolador ATmega. Si el interruptor está configurado en UART e intenta cargar el código en Arduino, se mostrará un mensaje de error en el IDE de Arduino.

Para cargar la Configuración del módulo WiFi código al Arduino y permita que Arduino configure el módulo WiFi, siga los pasos a continuación:

• 1. Coloque el interruptor en la posición DLINE;
• 2. Abra el IDE de Arduino, pegue y cargue el código en Arduino;
• 3. Tan pronto como finalice la carga, tendrá 5 segundos (retraso al comienzo del código) para cambiar el interruptor a la posición UART antes de que se envíen los comandos al módulo WiFi. Si se pierde el primer comando, ninguno de los demás funcionará. En este caso, simplemente reinicie el Arduino para que el boceto pueda ejecutarse nuevamente desde el principio.

Durante la configuración del módulo, que tarda unos 25 segundos, los LED del módulo parpadearán de forma diferente a su patrón estándar. En este momento sabrá que se está configurando el módulo WiFi.

Una vez configurado el módulo, intente hacer ping (Símbolo del sistema -> "ping [Dirección IP]" -> presione Entrar) el módulo utilizando la dirección IP especificada en establecer dirección IP mando. Si no obtiene una respuesta del módulo, algo salió mal en los pasos anteriores.

PASO 4:Planificación de los movimientos del robot

Aunque el robot tiene solo dos motores de CC, es capaz de realizar una serie de movimientos complejos. Para mantener este tutorial lo más simple posible, elegí definir solo alrededor de tres docenas de movimientos uniformes básicos y algunos movimientos complejos formados por la combinación de los movimientos básicos.

Como puedes ver en las imágenes del Paso 2, no utilizo sensores de rotación en las ruedas, sensores ultrasónicos o cualquier otro tipo de sensor para medir la distancia a los objetos o la distancia recorrida. Esto evita que el robot realice movimientos de alta precisión. Sin embargo, controlando solo la dirección y la velocidad de los motores, puede lograr un nivel de precisión lo suficientemente bueno como para mover el robot.

Lo primero que necesitas saber para poder calcular el tiempo de ejecución necesario para cada movimiento es la velocidad media del robot. Para ello, coloque una cinta métrica paralela al robot y active ambos motores simultáneamente durante uno o dos segundos, mida la distancia recorrida y deduzca la velocidad. En mi configuración, obtuve 13,7 centímetros por segundo empleando el 62,5% de la velocidad máxima del motor (250/400, consulte la biblioteca Pololu Arduino). En otras palabras, para mover el robot 1 metro (100 cm) hacia adelante, los motores debían activarse simultáneamente durante 7.299270… segundos. Elegí mantener el tiempo contando en la resolución de milisegundos, pero si desea lograr una mayor precisión de movimiento, considere aumentar la resolución a microsegundos. En pocas palabras, para mover el robot 1 metro, tengo que activar ambos motores simultáneamente durante 7299 milisegundos. A partir de este número, todo se convierte en regla de tres para otras distancias. Para realizar movimientos de arco o circulares, una rueda debe moverse más rápido que la otra. Para girar el robot hacia los lados, solo se debe activar una rueda o ambas en direcciones opuestas (para girar sobre su propio eje). Aquí tendrás que usar algo de trigonometría para calcular la distancia recorrida por cada rueda y por cuánto tiempo debe estar activado cada motor. Un buen punto de partida para estos conceptos se puede encontrar en los siguientes enlaces (no pretendo profundizar en esto aquí):http://rossum.sourceforge.net/papers/CalculationsForRobotics/CirclePath.htm y http:// math .stackexchange.com / preguntas / 60176 / mover-robot-de-dos-ruedas-de-un-punto-a-otro.

Como puede ver al final del video a continuación, también hago que el robot “dibuje” algunas formas geométricas básicas (cuadrado, triángulo y círculo) en el piso. Estos movimientos se logran mediante la combinación de movimientos básicos (por ejemplo, avanzar, girar, avanzar, girar, etc.). La combinación de estos movimientos se realiza en el esquema de voz del servidor BitVoicer y no los verá en el boceto de Arduino presentado en el siguiente paso.

PASO 5:Cargar el código en Arduino

En este paso, deberá cargar el boceto llamado Código fuente del robot , Ubicado en la parte inferior de este tutorial, al Arduino. También puede descargar el boceto de Arduino desde el siguiente enlace. Recuerde que para enviar código al Arduino debe colocar el interruptor en el escudo Sparkfun en la posición DLINE como se describe en el Paso 3. Antes de cargar el código, debe instalar correctamente el servidor BitVoicer y las bibliotecas del controlador del motor Pololu en el IDE de Arduino. (Importando una biblioteca .zip).

Código fuente del robot :BVS_Demo3.ino

Algunas partes de este boceto son similares a las partes que usé en uno de mis tutoriales anteriores y tratan de la comunicación con BitVoicer Server (clases BVSP y BVSMic). En este tutorial, me ceñiré a la explicación de las nuevas partes del boceto. Si desea obtener más información sobre cómo usar las clases BVSP y BVSMic, le sugiero que consulte el tutorial que mencioné anteriormente.

• Declaración de constantes :al comienzo del boceto, declaro una serie de constantes utilizadas a lo largo del código. El grupo de constantes con ajustes del motor define las velocidades predeterminadas del motor y las constantes de dos direcciones. La biblioteca de controladores de motor Pololu acepta valores de -400 a +400 para la velocidad del motor donde cero significa apagado. Los valores negativos indican rotación inversa o, si ha invertido los cables del motor como yo, rotación hacia adelante. El grupo de constantes con valores de comando se refiere a los comandos que se enviarán desde BitVoicer Server. En este boceto he definido solo 40 comandos básicos de byte tipo, pero se pueden realizar movimientos más complejos combinando estos comandos.
• Variables de control de ejecución :se definen cinco variables al principio del código para controlar la ejecución de los comandos ( motorSpeed ​​ , cmdDuration , cmdStartTime , cmdRunning e lastFwdCmd ). El motorSpeed ​​ La variable mantiene la velocidad actual del motor. Esta variable se actualiza con uno de los valores predeterminados definidos por las constantes de velocidad si el Arduino recibe un comando de BitVoicer Server para actualizar las velocidades del motor. La cmdDuration La variable contiene la duración total del comando actual. Esta variable se compara con el cmdStartTime variable en todas las iteraciones del bucle función si cmdRunning es verdadero . Si el tiempo de ejecución del comando ha expirado, el RunCommand Se llama a la función para detener los motores. El lastFwdCmd La variable contiene el último comando "ir / avanzar". Esta variable se utiliza para conocer la última distancia recorrida para que se pueda ejecutar el comando "volver". Tenga en cuenta que para usar este comando primero debe decirle al robot que se dé la vuelta.
• Conexión WiFi :al final del boceto defino dos funciones para conectar y desconectar de BitVoicer Server ( Connect y Desconectar ). Estas funciones ponen el módulo WiFi de Microchip en modo de comando, abren o cierran una conexión TCP / IP y devuelven el módulo al modo de datos. Dentro del bucle función, si la variable conectada no es verdadera , Llamo a Connect función. Si la clase BVSP informa que el estado del servidor ha expirado, en otras palabras, no se ha recibido respuesta para la última solicitud de estado, asumo que la conexión se ha perdido y llamo al Desconectar función. Esto forzará un nuevo intento de conexión en la siguiente iteración del ciclo.
• RunCommand función :esta función se llama cada vez que se recibe un comando de BitVoicer Server. Toma un byte valor que corresponde a uno de los comandos básicos definidos por las constantes al comienzo del croquis. Cada comando básico se identifica dentro del interruptor para que se puedan configurar las velocidades apropiadas del motor, así como la duración del comando. Al final de la función, el cmdRunning la variable se establece en true y el tiempo devuelto por milisegundos La función se almacena en cmdStartTime variable. Esto permite que Arduino controle la ejecución del comando como se describe arriba. Los tiempos, en milisegundos, para cada comando se obtuvieron como se describe en el paso anterior.

PASO 6:Configuración del servidor BitVoicer

En este paso, debe construir el esquema de voz del servidor BitVoicer con las oraciones a reconocer y los comandos que se enviarán al Arduino. Al final de este paso, hay dos enlaces a archivos que contienen todos los Objetos de solución de servidor BitVoicer utilizados en este tutorial. Si no desea crear todos los objetos de la solución uno por uno, puede importarlos (Importar objetos de la solución) usando estos archivos.

Antes de comenzar a construir el esquema de voz, debe crear un dispositivo que represente a Arduino en BitVoicer Server. Cree un dispositivo mixto y asígnele el nombre ArduinoUnoWiFi. En la pestaña Comunicación, seleccione TCP / IP e ingrese la dirección IP asignada al módulo WiFi en el Paso 3. En la pestaña Cues, habilite el Inicio del período activado y Fin del período activado señales. Seleccione los comandos Int16 SendData para ambas señales y seleccione el dispositivo ArduinoUnoWiFi como el destino de los comandos. En el campo Datos, ingrese 1 para el Inicio del período activado cue y 0 para el Fin del período activado señal. Estas señales harán que Arduino encienda un LED cada vez que se reconozca la palabra de activación. Cuando expire el período activado (definido en el esquema de voz), este LED se apagará.

Ahora creemos el esquema de voz. Aunque el robot tiene solo 40 comandos básicos, es posible que desee crear muchas combinaciones de palabras que activen el mismo comando. Por ejemplo, es posible que desee que las frases "avance un metro" y "avance un metro" para activar el mismo comando. Además, es posible que desee crear comandos complejos como "hacer un cuadrado" que activarán una serie de comandos temporizados en secuencia. Por eso, su esquema de voz puede crecer mucho y tener más de 40 comandos básicos. BitVoicer Server admite oraciones ilimitadas para que pueda definir tantas oraciones como necesite (la mía terminó con más de 80 oraciones). Aquí me gustaría dar dos consejos:cree un comando predeterminado en las Opciones del Administrador del Servidor BitVoicer; y copie y pegue comandos duplicados de una oración a las demás.

Los comandos de oración enviarán byte tipos de datos al Arduino. Utilice las constantes definidas al principio del esquema para saber qué valor debe enviarse para cada comando. Los comandos complejos enviarán muchos valores en secuencia y tendrá que controlar el intervalo (retraso) entre ellos para que no se envíe ningún valor mientras el comando anterior está en ejecución. Utilice el campo de retraso para establecer el intervalo entre comandos.

Archivos de objeto de solución :

Device.sof

VoiceSchema.sof

PASO 7:Conclusión

¡Ahora todo lo que tiene que hacer es colocar las baterías AA y conectar la batería de 9V al conector de alimentación Arduino para que su robot cobre vida! Después de cargar el código en Arduino, no olvide girar el interruptor montado en el escudo Sparkfun a la posición UART. De lo contrario, el módulo WiFi no recibirá ningún dato enviado desde el puerto serie Arduino.

Después de encender el robot, los LED de estado tardarán un poco en encenderse. Verá que el módulo WiFi inicia la comunicación y, cuando se establezca la conexión TCP / IP, uno de los LED del módulo se encenderá de forma fija. Después de unos instantes, también se encenderán tres de los cuatro LED de estado. Esto significa que se ha asignado un motor de reconocimiento de voz al Arduino. A partir de ahora, el robot está listo para recibir comandos.

Después de algunas pruebas con el robot, quedé bastante satisfecho con el reconocimiento de voz, aunque no reconocía el 100% de los comandos en todas las ocasiones. En este aspecto BitVoicer Server realmente me sorprendió. Sin embargo, no estaba muy satisfecho con la precisión de los movimientos del robot. Para solucionar este problema, tendría que agregar sensores de rotación a las ruedas. El kit de chasis que utilicé en el robot ya viene con discos decodificadores que se pueden conectar al equipo. La aplicación de sensores a estos discos me permitiría mover el robot en función de la distancia real recorrida para que su movimiento fuera más preciso. También podría agregar sensores ultrasónicos para evitar chocar con mis muebles. Probablemente lo haga algún día, pero por ahora, te lo dejo a ti.

¡Hasta la próxima!

Código

• Configuración del módulo WiFi
• Código fuente del robot

Configuración del módulo WiFi Arduino

Configura el módulo Microchip WiFi RN171VX usando el puerto serial Arduino.

 void setup () {Serial.begin (115200); pinMode (13, SALIDA); retraso (5000); Serial.print ("$$$"); retraso (1000); Serial.println ("establecer wlan auth 4"); retraso (1000); Serial.println ("establecer la frase wlan XXXXXX"); retraso (1000); Serial.println ("establecer wlan ssid XXXXXX"); retraso (1000); Serial.println ("establecer el canal WLAN 0"); retraso (1000); Serial.println ("establecer unión wlan 1"); retraso (1000); Serial.println ("establecer wlan tx 0"); retraso (1000); Serial.println ("establecer ip dhcp 0"); retraso (1000); Serial.println ("establecer dirección IP XXXXXX"); retraso (1000); Serial.println ("establecer comm remoto 0"); retraso (1000); Serial.println ("establecer comm close 0"); retraso (1000); Serial.println ("establecer comunicación abierta 0"); retraso (1000); Serial.println ("establecer tamaño de comunicación 500"); retraso (1000); Serial.println ("establecer tiempo de comunicación 50"); retraso (1000); Serial.println ("establecer uart baud 115200"); retraso (1000); Serial.println ("establecer el flujo de uart 0"); retraso (1000); Serial.println ("guardar"); retraso (1000); Serial.println ("salir"); retraso (1000); digitalWrite (13, LOW);} bucle vacío () {} 

Código fuente del robot Arduino

Controla los movimientos del robot, captura audio, administra la conexión TCP / IP y se comunica con BitVoicer Server.

 #include  #include  #include  // Define los pines Arduino that will be used to control// LEDs and capture audio#define BVS_RUNNING 2#define BVS_SRE 5#define BVS_DATA_FWD 3#define BVS_ACT_PERIOD 6#define BVSM_AUDIO_INPUT 3// Defines the constants that will be passed as parameters to // the BVSP.begin functionconst unsigned long STATUS_REQUEST_INTERVAL =2000;const unsigned long STATUS_REQUEST_TIMEOUT =1000;// Defines the size of the mic bufferconst int MIC_BUFFER_SIZE =64;// Initializes a new global instance of the BVSP classBVSP bvsp =BVSP();// Initializes a new global instance of the BVSMic classBVSMic bvsm =BVSMic();// Initializes a new global instance of the // DualMC33926MotorShield classDualMC33926MotorShield ms =DualMC33926MotorShield();// Creates a buffer that will be used to read recorded samples // from the BVSMic classbyte micBuffer[MIC_BUFFER_SIZE];// Creates a global variable that indicates whether the // Arduino is connected to BitVoicer Serverboolean connected =false;// Defines some constants for the motor settingsconst int SPEED_STOP =0;const int SPEED_SLOW =100;const int SPEED_NORMAL =250;const int SPEED_FAST =400;const int DIRECTION_FRONT =-1;const int DIRECTION_BACK =1;// Declares a global variables to hold the current motor speed.// The default is SPEED_NORMAL, but there are voice // commands that change this setting.int motorSpeed =SPEED_NORMAL;// Stores the command duration in millisecondsunsigned long cmdDuration =0;// Stores the time the command started runningunsigned long cmdStartTime =0;// Stores whether a command is running or notbool cmdRunning =false;// Stores the last MOVE_FORWARD command. This variable // is used only for the COME_BACK command.byte lastFwdCmd =0;// Defines some constants for command names/values// Just to make the code more readableconst byte CMD_STOP =0;const byte CMD_MOVE_FORWARD =1;const byte CMD_MOVE_FORWARD_1_CM =2;const byte CMD_MOVE_FORWARD_2_CM =3;const byte CMD_MOVE_FORWARD_5_CM =4;const byte CMD_MOVE_FORWARD_10_CM =5;const byte CMD_MOVE_FORWARD_25_CM =6;const byte CMD_MOVE_FORWARD_50_CM =7;const byte CMD_MOVE_FORWARD_1_M =8;const byte CMD_MOVE_BACKWARD =9;const byte CMD_MOVE_BACKWARD_1_CM =10;const byte CMD_MOVE_BACKWARD_2_CM =11;const byte CMD_MOVE_BACKWARD_5_CM =12;const byte CMD_MOVE_BACKWARD_10_CM =13;const byte CMD_MOVE_BACKWARD_25_CM =14;const byte CMD_MOVE_BACKWARD_50_CM =15;const byte CMD_MOVE_BACKWARD_1_M =16;const byte CMD_TURN_AROUND =17;const byte CMD_TURN_AROUND_RIGHT =18;const byte CMD_TURN_AROUND_LEFT =19;const byte CMD_DO_360 =20;const byte CMD_TURN_RIGHT =21;const byte CMD_TURN_RIGHT_10 =22;const byte C MD_TURN_RIGHT_25 =23;const byte CMD_TURN_RIGHT_45 =24;const byte CMD_TURN_LEFT =25;const byte CMD_TURN_LEFT_10 =26;const byte CMD_TURN_LEFT_25 =27;const byte CMD_TURN_LEFT_45 =28;const byte CMD_DO_CIRCLE =29;const byte CMD_COME_BACK =30;const byte CMD_MOVE_FORWARD_2_M =31;const byte CMD_MOVE_FORWARD_3_M =32;const byte CMD_MOVE_BACKWARD_2_M =33;const byte CMD_MOVE_BACKWARD_3_M =34;const byte CMD_SET_SPEED_SLOW =35;const byte CMD_SET_SPEED_NORMAL =36;const byte CMD_SET_SPEED_FAST =37;const byte CMD_TURN_LEFT_45_BACKWARD =38;const byte CMD_TURN_RIGHT_45_BACKWARD =39;void setup(){ // Starts serial communication at 115200 bps Serial.begin(115200); // Sets the Arduino pin modes pinMode(BVS_RUNNING, OUTPUT); pinMode(BVS_SRE, OUTPUT); pinMode(BVS_DATA_FWD, OUTPUT); pinMode(BVS_ACT_PERIOD, OUTPUT); AllLEDsOff(); // Sets the Arduino serial port that will be used for // communication, how long it will take before a status request // times out and how often status requests should be sent to // BitVoicer Server bvsp.begin(Serial, STATUS_REQUEST_TIMEOUT, STATUS_REQUEST_INTERVAL); // Sets the function that will handle the frameReceived // event bvsp.frameReceived =BVSP_frameReceived; // Prepares the BVSMic class timer bvsm.begin(); // Prepares the motor shield class (pins and timer1) ms.init();}void loop() { // If it is not connected to the server, opens a TCP/IP // connection, sets connected to true and resets the BVSP // class if (!connected) { Connect(Serial); connected =true; bvsp.reset(); } // Checks if the status request interval has elapsed and if it // has, sends a status request to BitVoicer Server bvsp.keepAlive(); // Checks if there is data available at the serial port buffer // and processes its content according to the specifications // of the BitVoicer Server Protocol bvsp.receive(); // Gets the respective status from the BVSP class and sets // the LEDs on or off digitalWrite(BVS_RUNNING, bvsp.isBVSRunning()); digitalWrite(BVS_DATA_FWD, bvsp.isDataFwdRunning()); // Checks if there is a SRE assigned to the Arduino if (bvsp.isSREAvailable()) { // Turns on the SRE available LED digitalWrite(BVS_SRE, HIGH); // If the BVSMic class is not recording, sets up the audio // input and starts recording if (!bvsm.isRecording) { bvsm.setAudioInput(BVSM_AUDIO_INPUT, EXTERNAL); bvsm.startRecording(); } // Checks if the BVSMic class has available samples if (bvsm.available) { // Makes sure the inbound mode is STREAM_MODE before // transmitting the stream if (bvsp.inboundMode ==FRAMED_MODE) bvsp.setInboundMode(STREAM_MODE); // Reads the audio samples from the BVSMic class int bytesRead =bvsm.read(micBuffer, MIC_BUFFER_SIZE); // Sends the audio stream to BitVoicer Server bvsp.sendStream(micBuffer, bytesRead); } } else { // There is no SRE available // Turns off the SRE and ACT_PERIOD LEDs digitalWrite(BVS_SRE, LOW); digitalWrite(BVS_ACT_PERIOD, LOW); // If the BVSMic class is recording, stops it if (bvsm.isRecording) bvsm.stopRecording(); } // If the status has timed out, the connection is considered // lost if (bvsp.hasStatusTimedOut()) { // If the BVSMic is recording, stops it if (bvsm.isRecording) bvsm.stopRecording(); // Closes the TCP/IP connection Disconnect(Serial); AllLEDsOff(); connected =false; } // If a command is running, checks if its duration has // expired. If it has, stop the motors. if (cmdRunning) if (millis() - cmdStartTime>=cmdDuration) RunCommand(CMD_STOP);}// Handles the frameReceived eventvoid BVSP_frameReceived(byte dataType, int payloadSize){ // Performs the appropriate actions based on the frame // data type. If the data type is byte, it is a command. // If the data type is int, changes the activated // period LED. switch (dataType) { case DATA_TYPE_BYTE:RunCommand(bvsp.getReceivedByte()); descanso; case DATA_TYPE_INT16:digitalWrite(BVS_ACT_PERIOD, bvsp.getReceivedInt16()); descanso; }}// Runs the command received from the servervoid RunCommand(byte cmd){ switch (cmd) { case CMD_STOP:ms.setSpeeds(SPEED_STOP, SPEED_STOP); cmdRunning =false; regreso; case CMD_MOVE_FORWARD:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =60000; descanso; case CMD_MOVE_FORWARD_1_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =23; descanso; case CMD_MOVE_FORWARD_2_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =47; descanso; case CMD_MOVE_FORWARD_5_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =117; descanso; case CMD_MOVE_FORWARD_10_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =234; descanso; case CMD_MOVE_FORWARD_25_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =468; descanso; case CMD_MOVE_FORWARD_50_CM:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =1170; descanso; case CMD_MOVE_FORWARD_1_M:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =2339; descanso; case CMD_MOVE_FORWARD_2_M:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =4678; descanso; case CMD_MOVE_FORWARD_3_M:lastFwdCmd =cmd; ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_FRONT); cmdDuration =7018; descanso; case CMD_MOVE_BACKWARD:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =60000; descanso; case CMD_MOVE_BACKWARD_1_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =23; descanso; case CMD_MOVE_BACKWARD_2_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =47; descanso; case CMD_MOVE_BACKWARD_5_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =117; descanso; case CMD_MOVE_BACKWARD_10_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =234; descanso; case CMD_MOVE_BACKWARD_25_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =468; descanso; case CMD_MOVE_BACKWARD_50_CM:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =1170; descanso; case CMD_MOVE_BACKWARD_1_M:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =2339; descanso; case CMD_MOVE_BACKWARD_2_M:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =4678; descanso; case CMD_MOVE_BACKWARD_3_M:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_BACK); cmdDuration =7017; descanso; case CMD_TURN_AROUND:ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_BACK); cmdDuration =540; descanso; case CMD_TURN_AROUND_RIGHT:ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_BACK); cmdDuration =540; descanso; case CMD_TURN_AROUND_LEFT:ms.setSpeeds( motorSpeed * DIRECTION_BACK, motorSpeed * DIRECTION_FRONT); cmdDuration =540; descanso; case CMD_DO_360:ms.setSpeeds( motorSpeed * DIRECTION_FRONT, motorSpeed * DIRECTION_BACK); cmdDuration =1065; descanso; case CMD_TURN_RIGHT:ms.setSpeeds(motorSpeed * DIRECTION_FRONT, 0); cmdDuration =503; descanso; case CMD_TURN_RIGHT_10:ms.setSpeeds(motorSpeed * DIRECTION_FRONT, 0); cmdDuration =56; descanso; case CMD_TURN_RIGHT_25:ms.setSpeeds(motorSpeed * DIRECTION_FRONT, 0); cmdDuration =140; descanso; case CMD_TURN_RIGHT_45:ms.setSpeeds(motorSpeed * DIRECTION_FRONT, 0); cmdDuration =252; descanso; case CMD_TURN_LEFT:ms.setSpeeds(0, motorSpeed * DIRECTION_FRONT); cmdDuration =503; descanso; case CMD_TURN_LEFT_10:ms.setSpeeds(0, motorSpeed * DIRECTION_FRONT); cmdDuration =56; descanso; case CMD_TURN_LEFT_25:ms.setSpeeds(0, motorSpeed * DIRECTION_FRONT); cmdDuration =140; descanso; case CMD_TURN_LEFT_45:ms.setSpeeds(0, motorSpeed * DIRECTION_FRONT); cmdDuration =252; descanso; case CMD_DO_CIRCLE:ms.setSpeeds( SPEED_NORMAL * DIRECTION_FRONT, SPEED_NORMAL * DIRECTION_FRONT * 0.60); cmdDuration =4587; descanso; case CMD_COME_BACK:RunCommand(lastFwdCmd); regreso; case CMD_SET_SPEED_SLOW:motorSpeed =SPEED_SLOW; regreso; case CMD_SET_SPEED_NORMAL:motorSpeed =SPEED_NORMAL; regreso; case CMD_SET_SPEED_FAST:motorSpeed =SPEED_FAST; regreso; case CMD_TURN_LEFT_45_BACKWARD:ms.setSpeeds(motorSpeed * DIRECTION_BACK, 0); cmdDuration =252; descanso; case CMD_TURN_RIGHT_45_BACKWARD:ms.setSpeeds(0, motorSpeed * DIRECTION_BACK); cmdDuration =252; descanso; } // Sets the command start time cmdStartTime =millis(); // Sets cmdRunning to true cmdRunning =true;}// Opens a TCP/IP connection with the BitVoicer Servervoid Connect(HardwareSerial &serialPort){ serialPort.print("$$$"); retraso (500); // Use the IP address of the server and the TCP port set // in the server properties serialPort.println("open 192.168.0.11 4194"); retraso (1000); serialPort.println("exit"); delay(500);}// Closes the TCP/IP connection with the BitVoicer Servervoid Disconnect(HardwareSerial &serialPort){ serialPort.print("$$$"); retraso (500); serialPort.println("close"); retraso (1000); serialPort.println("exit"); delay(500);}// Turns all LEDs offvoid AllLEDsOff(){ digitalWrite(BVS_RUNNING, LOW); digitalWrite(BVS_SRE, LOW); digitalWrite(BVS_DATA_FWD, LOW); digitalWrite(BVS_ACT_PERIOD, LOW);}

Esquemas

Generación de menú LCD sin código usando XOD T-Rex-duino - Clon Arduino del juego Chrome T-Rex