Las aplicaciones de microcontroladores no se limitan al control de dispositivos eléctricos o electrónicos simples, sino que hoy en día se utilizan ampliamente en las industrias de la robótica y la automoción. El microcontrolador realiza desde el simple control del espejo retrovisor hasta complejas funciones de control del motor. El microcontrolador puede incluso implementar el control automático del vehículo sin un conductor humano en su interior y este tipo de vehículos se denominan Vehículos No Tripulados (UV). Los rayos UV se utilizan comúnmente en los campos de investigación, militar, rescate y agricultura. Para cualquier UV, es necesario un seguimiento en tiempo real de su trayectoria para garantizar que se mueven en la trayectoria correcta.
Este proyecto demuestra cómo es posible crear un dispositivo de seguimiento de trayectoria más sencillo para un vehículo terrestre con la ayuda de un ratón óptico . Un mouse óptico es un dispositivo que tiene una cámara muy pequeña en su interior que puede detectar el movimiento del suelo debajo y comunicar el cambio en las coordenadas XY con un dispositivo externo a través de protocolos de comunicación en serie simples. Este proyecto utiliza un mouse óptico que funciona con el protocolo PS2 y se conecta con una placa Arduino para leer datos de ella. Luego, los datos del mouse se transmiten de forma inalámbrica utilizando un par de transceptores Xbee a una computadora distante, donde los datos se muestran gráficamente como una pista en la que se produce el movimiento del mouse.
Xbee es la marca de un dispositivo transceptor inalámbrico que funciona con el protocolo ZigBee. ZigBee es el nombre de un protocolo inalámbrico mantenido por el estándar IEEE 802.15. Este es un protocolo especificado para redes de área personal (PAN) inalámbricas que utilizan transceptores inalámbricos de baja potencia. También se pueden utilizar para sistemas de comunicación sencillos punto a punto.
En este proyecto se utilizan dos módulos transceptores de la serie Xbee S1 y la imagen del mismo módulo se muestra en la siguiente figura. Dado que el paso de pines de los módulos no es compatible con la placa de pruebas, puede utilizar las placas de diseño basadas en Xbee que vienen con pines compatibles con la placa de pruebas.
Fig. 2: Módulo transceptor de la serie Xbee S1
Dado que los módulos Xbee se comunican mediante un protocolo de comunicación en serie con los dispositivos de interfaz, se pueden conectar a un microcontrolador utilizando un mínimo de cuatro pines, fuente de alimentación y tierra, salida de datos UART y entrada de datos UART. El pin número 2, la salida de datos UART está conectado al pin RX1 de la mini placa Arduino pro y el pin número 3, los datos UART están conectados al pin TX0.
En este proyecto se utiliza la placa Arduino pro-mini, la cual viene preprogramada con el gestor de arranque Arduino . El IDE de programación utilizado para este proyecto es Arduino IDE versión 1.0.3 en el sistema operativo Windows. La imagen de la placa Arduino pro-mini y el IDE de Arduino se muestra a continuación:
Fig. 3: Placa típica Arduino Pro-Mini
Fig. 4: Ventana del software Arduino IDE
Otro hardware que puede realizar la conversión de USB a TTL se utiliza para cargar el programa en la placa Arduino. Esta placa también se puede utilizar cuando sea necesario realizar comunicación serie entre el PC y la placa Arduino.
5: Placa convertidora externa de USB a TTL para programación Arduino y comunicación en serie
Se supone que el lector ha leído el proyecto sobre cómo empezar con Arduino y ha hecho todo lo que se comenta en él.
El mouse de PS2 utiliza una comunicación síncrona con la PC que es muy similar al protocolo de interfaz de dos cables. El conector PS2 tiene un pin para Datos y otro pin para Reloj y usando solo estos dos pines el mouse se comunica con el dispositivo host. El mouse siempre tiene un conector mini-DIN macho de 6 pines para interfaz PS2, y el dispositivo host siempre tiene el pin hembra correspondiente. Las imágenes y pinouts de los conectores macho y hembra de PS2 se muestran en la siguiente imagen:
La imagen del pin masculino de PS2
6: Conector macho mini-DIN de 6 pines para interfaz PS2
La imagen del pin femenino de PS2
Fig. 7: Conector hembra Mini DIN de 6 pines para interfaz PS2
El pinout de los conectores macho y hembra de PS2
Fig. 8: Distribución de pines de los conectores PS2 macho y hembra
Cuando se trata de conectar el conector hembra a la placa de circuito, deberías poder identificar los pines en la parte inferior del conector PS2 y la siguiente imagen te será útil.
Fig. 9: Parte inferior del conector hembra Mini DIN para interfaz PS2
El código escrito para este proyecto utiliza el archivo de biblioteca personalizado de PS2 llamado "PS2Mouse.h", que tiene todas las rutinas necesarias para acceder a un mouse de PS2. Hay dos funciones que el usuario puede utilizar directamente en su código: “mouse.initialize” y “mouse.report (datos)”. El método de lectura de datos del mouse PS2 usando las funciones anteriores y decodificación para obtener las coordenadas XY se explica en un proyecto anterior sobre cómo conectar un mouse PS2 con Arduino .
La implementación del proyecto que puede recibir datos del mouse de PS2 y transmitir las coordenadas XY extraídas de los datos del mouse a través de Xbee se representa mediante el siguiente diagrama de bloques:
Fig. 10: Diagrama de bloques del sistema de seguimiento de ruta inalámbrico usando mouse y Xbee con Ardiuno
El código escrito para este proyecto en Arduino lee datos del mouse PS2 continuamente y escribe los datos en Xbee para su transmisión con la ayuda de funciones de comunicación en serie proporcionadas por Arduino IDE. En este proyecto se utilizan funciones como Serial.begin que ayuda a inicializar el puerto serie con una determinada velocidad en baudios, Serial.write para enviar datos al puerto serie, Serial.available y Serial.read para leer datos del puerto serie. y ya se han discutido en proyectos anteriores sobre cómo realizar comunicación en serie con Arduino , cómo enviar y recibir datos en serie usando Arduino y cómo realizar depuración en serie con Arduino . El método para obtener los datos XY requeridos del mouse de PS2 se explica en el proyecto anterior sobre cómo conectar un mouse de PS2 con Arduino . El método de interconectar un módulo Xbee y transmitir datos usándolo se analiza en el proyecto anterior sobre cómo interconectar el módulo Xbee con Arduino .
El código lee cientos de conjuntos de datos del mouse a la vez y calcula el cambio promedio en el valor X de esos datos. Este valor promedio del cambio en la coordenada X se utiliza luego para compensar la posición de un carácter '*' en una línea que debe transmitirse y mostrarse en la computadora distante. Por lo tanto, a medida que se mueve el mouse, el valor promedio del cambio en la dirección X varía, lo que varía la posición del carácter '*' en la ventana del monitor serie en la PC distante. Dado que el carácter '*' se imprime continuamente cada vez en una nueva línea con una posición de acuerdo con el movimiento del mouse, se puede considerar similar al rastro dibujado que sigue el movimiento del mouse en la dirección X.
Cuando se complete la codificación, podrá verificar y cargar el código en la placa Arduino como se explica en el proyecto Cómo comenzar con Arduino . Tan pronto como se enciende la placa, el Xbee en la placa Arduino establece automáticamente comunicación con otro Xbee que esté conectado al puerto serie de una PC. La segunda placa Xbee se puede conectar a la PC usando la misma placa convertidora de USB a TTL que se usó para programar la placa Arduino. Mueva el mouse y se podrá observar el cambio en la pista usando cualquier software de monitoreo en serie o usando el propio software de monitoreo en serie del IDE de Arduino, como se explica en el proyecto cómo realizar la depuración en serie con Arduino .
Código fuente del proyecto
### /*============================= EG LABS ================== ===================// Demostración sobre cómo enviar de forma inalámbrica datos de información de ruta del movimiento de un mouse PS2 en dirección X usando Xbee El circuito: LCD: * Pin LCD RS a pin digital 12 * LCD habilita pin a pin digital 11 * Pin LCD D4 a pin digital 7 * Pin LCD D5 a pin digital 6 * LCD D6 pin a digital pin 5 * Pin LCD D7 a pin digital 4 * LCD R/W pin a tierra * Resistencia de 10K: * termina en +5V y tierra *limpiador al pin 3 del LCD * Ánodo LED conectado a la salida digital 9 * Cátodo LED conectado a tierra a través de una resistencia de 1K RATÓN: FECHA PIN A PIN NÚMERO 8 RELOJ PIN A PIN NÚMERO 3 XBEE: PIN RX DE XBEE AL PIN TX0 DE ARDUINO CORTO LOS PINES DE TIERRA DE ARDUINO Y XBEE =============================== EG LABS ================== = ==================*/ #incluir "PS2Mouse.h" #definir MOUSE_DATA 8 #definir MOUSE_CLOCK 3 // incluye el código de la biblioteca: #incluir// inicializa la biblioteca con los números de los pines de la interfaz LCD de cristal líquido (12, 11, 7, 6, 5, 4); // inicializa la biblioteca del mouse PS2Mouse ratón(MOUSE_CLOCK, MOUSE_DATA, STREAM); ent i; int x_acc = 0; int pos = 0; datos int(2); configuración vacía { pinMode(9, SALIDA); // configura el número de columnas y filas de la pantalla LCD: lcd.comenzar(16, 2); lcd.print("GARAJE PARA INGENIEROS"); lcd.setCursor(0, 1); lcd.print(" RATÓN a XBEE "); retraso(2000); escritura digital (9, ALTA); Serie.begin(9600); ratón.inicializar; // inicializamos el ratón PS2 conectado con el Arduino } bucle vacío { x_acc = 0; para(yo = 0; yo < 100; yo++) { del { ratón.informe(datos); //obtener datos del mouse }mientras(datos(1) == 0); x_acc += datos(1); } //=== obtiene el movimiento promedio en la dirección x ===// x_acc = x_acc / 200; x_acc = x_acc + pos; si(x_acc > 100) x_acc = 100; demás; //=== obtiene el movimiento promedio en la dirección x ===// Serial.println; para(i = 0; i < (100 + x_acc); i ++) Serie.print(" "); Serie.print("*"); pos = x_acc; } ###
Código fuente del proyecto
### //#incluye "WConstants.h" #incluir "HardwareSerial.h" #incluir "PS2Mouse.h" #incluir "Arduino.h" PS2Mouse::PS2Mouse(int reloj_pin, int datos_pin, int modo) { _pin_reloj = pin_reloj; _pin_datos = pin_datos; _modo = modo; _inicializado = falso; _discapacitado = verdadero; _enabled = falso; } int PS2Mouse::clock_pin { devolver _clock_pin; } int PS2Mouse::pin_datos { devolver _data_pin; } anular PS2Mouse::inicializar { pull_high(_clock_pin); pull_high(_data_pin); retraso(20); escribir(0xff); //Enviar Restablecer al mouse byte_lectura; // Leer byte de confirmación retraso(20); // No estoy seguro de por qué esto necesita el retraso byte_lectura; //blanco byte_lectura; //blanco retraso(20); // No estoy seguro de por qué esto necesita el retraso si (_modo == REMOTO) { establecer_modo_remoto; } demás { enable_data_reporting; // Dile al mouse que comience a enviar datos nuevamente } retrasoMicrosegundos(100); _inicializado = 1; } anular PS2Mouse::set_mode(int datos) { si (_mode == TRANSMISIÓN) { desactivar_informes_datos; // Dile al mouse que deje de enviar datos. } escribir(datos); // Enviar modo de configuración byte_lectura; // Leer el byte de confirmación si (_mode == TRANSMISIÓN) { enable_data_reporting; // Dile al mouse que comience a enviar datos nuevamente } si (_inicializado) { retrasoMicrosegundos(100); } } anular PS2Mouse::set_remote_mode { set_mode(0xf0); _modo = REMOTO; } anular PS2Mouse::set_stream_mode { set_mode(0xea); _modo = TRANSMISIÓN; } anular PS2Mouse::set_sample_rate(velocidad int) { si (_mode == TRANSMISIÓN) { desactivar_informes_datos; // Dile al mouse que deje de enviar datos. } escribir(0xf3); // Dile al mouse que vamos a configurar la frecuencia de muestreo. byte_lectura; // Leer byte de confirmación escribir (tasa); // Enviar establecer frecuencia de muestreo byte_lectura; // Leer byte de confirmación si (_mode == TRANSMISIÓN) { enable_data_reporting; // Dile al mouse que comience a enviar datos nuevamente } retrasoMicrosegundos(100); } anular PS2Mouse::set_scaling_2_1 { set_mode(0xe7); // Establece la escala en 2:1 } anular PS2Mouse::set_scaling_1_1 { set_mode(0xe6); // establece la escala a 1:1 } // Esto solo afecta el informe de datos en modo Stream. anular PS2Mouse::enable_data_reporting { si (!_enabled) { escribir(0xf4); // Enviar informes de datos habilitados byte_lectura; // Leer byte de confirmación _enabled = verdadero; } } // Deshabilitar el informe de datos en el modo Stream hará que se comporte como el modo remoto anular PS2Mouse::disable_data_reporting { si (!_disabled) { escribir(0xf5); // Enviar informes de datos deshabilitados byte_lectura; // Leer byte de confirmación _discapacitado = verdadero; } } anular PS2Mouse::set_solving(resolución int) { si (_mode == TRANSMISIÓN) { enable_data_reporting; } escribir(0xe8); // Enviar resolución establecida byte_lectura; // Leer byte de confirmación escribir (resolución); // Enviar configuración de resolución byte_lectura; // Leer byte de confirmación si (_mode == TRANSMISIÓN) { desactivar_informes_datos; } retrasoMicrosegundos(100); } anular PS2Mouse::write(int datos) { carácter i; paridad de caracteres = 1; pull_high(_data_pin); pull_high(_clock_pin); retrasoMicrosegundos(300); pull_low(_clock_pin); retrasoMicrosegundos(300); pull_low(_data_pin); retrasoMicrosegundos(10); pull_high(_clock_pin); // Bit de inicio while (digitalRead(_clock_pin)) {;} // espera a que el mouse tome el control del reloj) // el reloj está bajo y podemos enviar datos para (i=0; i < 8; i++) { si (datos y 0x01) { pull_high(_data_pin); } demás { pull_low(_data_pin); } // esperar el ciclo del reloj mientras (!digitalRead(_clock_pin)) {;} mientras (digitalRead(_clock_pin)) {;} paridad = paridad ^ (datos y 0x01); fecha = fecha >> 1; } //paridad si (paridad) { pull_high(_data_pin); } demás { pull_low(_data_pin); } mientras (!digitalRead(_clock_pin)) {;} mientras (digitalRead(_clock_pin)) {;} pull_high(_data_pin); retrasoMicrosegundos(50); mientras (digitalRead(_clock_pin)) {;} while ((!digitalRead(_clock_pin)) (!digitalRead(_data_pin))) {;} // espera a que el mouse cambie de modo pull_low(_clock_pin); // retener los datos entrantes. } int * PS2Mouse::informe(int datos) { escribir(0xeb); // Enviar datos leídos byte_lectura; // Leer byte de confirmación datos(0) = leer; // bit de estado datos(1) = read_movement_x(datos(0)); // Paquete de movimiento X datos(2) = read_movement_y(datos(0)); // Paquete de movimiento Y datos de devolución; } int PS2Mouse::leer { devolver byte_lectura; } int PS2Mouse::read_byte { datos enteros = 0; pull_high(_clock_pin); pull_high(_data_pin); retrasoMicrosegundos(50); mientras (digitalRead(_clock_pin)) {;} retrasoMicrosegundos(5); // no estoy seguro de por qué. while (!digitalRead(_clock_pin)) {;} // come el bit de inicio para (int i = 0; i < 8; i++) { bitWrite(datos, i, read_bit); } bit_lectura; // Bit de fiesta bit_lectura; // El bit de parada debe ser 1 pull_low(_clock_pin); datos de devolución; } int PS2Mouse::read_bit { mientras (digitalRead(_clock_pin)) {;} int bit = digitalRead(_data_pin); mientras (!digitalRead(_clock_pin)) {;} bit de retorno; } int PS2Mouse::read_movement_x(int estado) { int x = leer; si (bitRead(estado, 4)) { para(int i = 8; i < 16; ++i) { x = (1< pinMode(pin, SALIDA); escritura digital (pin, BAJO); } anular PS2Mouse::pull_high(int pin) { pinMode(pin, ENTRADA); escritura digital (pin, ALTO); } **************Archivo de encabezado para la interfaz del mouse****************
#definir PS2Mouse_h #definir REMOTO 1 #definir CORRIENTE 2 clase PS2Ratón { privado: int _clock_pin; int _datos_pin; int_modo; int _inicializado; int_enabled; int _discapacitado; int lectura_byte; int lectura_bit; int lectura_movimiento_x(int); int lectura_movimiento_y(int); vacío pull_high(int); vacío pull_low(int); vacío set_mode(int); público: PS2Mouse(int, int, modo int = REMOTO); inicialización nula; int reloj_pin; int pin_datos; int leer; informe int*(datos int); escritura nula (int); anular enable_data_reporting; anular enable_data_reporting; anular set_remote_mode; vacío set_stream_mode; void set_resolución(int); vacío set_scaling_2_1; vacío set_scaling_1_1; void set_sample_rate(int); }; #terminara si###
Diagramas de circuito
| Diagrama de circuito para crear un sistema de seguimiento de ruta inalámbrico usando mouse-XBee-Arduino |  |
Componentes del proyecto
- Arduino ProMini
- LCD
- CONDUJO
- Resistor
Vídeo del proyecto