Paso 1: Obtener el mando de la Xbox con el Arduino
Enchufe el USB Host Shield en el Arduino. Por ahora, potencia el Arduino con usted es computadora. A continuación enchufe el Xbox 360™ Wireless Gaming Receiver for Windows®. Una vez que estas conexiones se hacen carga de código que se muestra a continuación en el Arduino que permite el Arduino realizar operaciones de manejo basadas en la entrada del controlador.
Hay un montón de la notación para ayudar a entender lo que está sucediendo.
Código de Arduino
// ****************************** RC Power Wheels Jeep *
// *****************************
/*
RESUMEN
Un huracán de Jeep 12v doble motor potencia ruedas tendrá unidad
y manejo controlado remotamente a través de Arduino.
HARDWARE
Power Wheels Jeep Hurricane
Arduino UNO R3
Circuitos USB Host Shield 2.0 http://www.circuitsathome.com/products-page/arduino-shields/usb-host-shield-2-0-for-arduino
Pololu regulador Simple del Motor 18v25 http://www.pololu.com/catalog/product/1381/resources
Pololu regulador del Motor de JRK 12v12 http://www.pololu.com/catalog/product/1393/resources
Chip genérico lineal actuador 4".6"/s http://www.pololu.com/catalog/product/2333
Adaptador USB inalámbrico de Xbox 360
Controlador inalámbrico Xbox 360
CONFIGURACIÓN DE HARDWARE
* +-------+ +---------------+ USB +-----------------+
* | Arduino +---> | USB Host Shield +---> | XBOX USB Receiver| *** / >< / *** controlador inalámbrico XBOX
* +-+-----+ +---------------+ +-----------------+
* |
* | TX (Serial de la TTL)
* |
* |------------------|
* | |
* v v Rx Rx
* +----------+ +----------+
* | Pololu SMC + | Chip Jrk|
* +----------+ +----------+
* Maestro esclavo
* + +
* | |
* | |
* v v
* +--------+ +--------+
* | 12v| doble | Lineal |
* | Motores | | Actuator|
* +--------+ +--------+
*
* NOTAS
* Al aire libre con línea de vista, el controlador de inalámbrico Xbox tiene una gama impresionante. El rango máximo
* no ha sido completamente probado, pero me he ido más de 50ft sin ninguna pérdida notable en la señal.
*
* Todo se encuentra a bordo del Jeep. Todas las conexiones Serial TTL son hard-wired en el Arduino
* y controladores de motor. El receptor de Xbox está conectado a una barra de metal al estilo de antena.
*
* El actuador linear actual puede ser demasiado lento. Puede moverse hay 110 libras de fuerza pero al.6"/ s.
* es un modelo más rápido que hace 22 lbs. @ 1.5"/ s http://www.pololu.com/catalog/product/2345
*
*/
*** Incluye el escudo de la USB de circuitos ***
#include < XBOXRECV.h > / / receptor inalámbrico Xbox 360
¿Crear instancia USB? ESCUDO DE LA USB
USB Usb;
Crear una instancia del receptor Xbox entradas llamados XboxRCV
XBOXRECV XboxRCV(&Usb); ESCUDO DE LA USB
Estas constantes siguientes forman parte de bytes del protocolo Pololu
pololuCommandByte byte const = 170;
smcDeviceNumber byte const = 13;
smcSpeedDataByte3 byte const = 0;
smcFWDbyte byte const = 5;
smcREVbyte byte const = 6;
jrkDeviceNumber byte const = 11;
char smcSpeed; Velocidad final
leftStickX int largo; Valor de Xbox izquierda Analog Stick
void setup() {}
Serial.Begin(9600); Velocidad de transmisión serial a 9600
Detener el programa hasta que el escudo está conectado
USB. Init devuelve -1 para blindaje desconectado y 0 si está conectado
Si (Usb.Init() == -1) {/ / protector de USB si no inicializar por cualquier motivo...
while(1); detener como escudo se divulga desconectado
}
}
void loop() {}
Usb.Task();
Vamos a procesar la entrada de la Xbox
{if(XboxRCV.Xbox360Connected[0])}
INICIAR botón envía exitSafeStart comando para SMC
{if(XboxRCV.getButtonClick(Start,0))}
// *******************************
* exitSafeStart *
// *******************************
Necesario para permitir motores conectados al SMC para mover
Debe ser llamada cuando se reinicia el controlador y después de cualquier error
Protocolo de Pololu: 0xAA (170) | número de dispositivo | 0 x 03 (3)
Serial.Write(pololuCommandByte);
Serial.Write(smcDeviceNumber);
Serial.Write(3);
}
/ * Los gatillos del Xbox proporcionan valores de 0 - 255. El SMC aceptará una baja
valor de la velocidad de resolución porcentaje 0% - 100% (de alta resolución es
un int 2 bytes). Mapas de las dos líneas el controlador de salida de un
valor negativo de L2 (inversa) y positivo para R2 (adelante). Estos dos
luego se suman los valores para proporcionar la velocidad final y la dirección. Se trata de
para que ambos disparadores pueden celebrarse también sin causar los valores
a oscilar entre adelante y atrás
*/
char XboxL2 = map((XboxRCV.getButtonPress(L2,0)), 0, 255, 0, -100);
char XboxR2 = map((XboxRCV.getButtonPress(R2,0)), 0, 255, 0, 100);
Suma de las entradas asignadas para dar una velocidad final y la dirección
smcSpeed = XboxL2 + XboxR2;
/ * El ejemplo de código para el controlador de Xbox dio una zona muerta de-7500 a 7500.
Este código mantiene esa zona muerta por ahora (me gustaría hacerlo
ajustable mientras se está ejecutando el bosquejo). */
leftStickX = map(XboxRCV.getAnalogHat(LeftHatX,0),-32768, 0, 32767, 3880); Stick analógico movido
Ajustar la banda muerta en el stick analógico izquierdo. Como esto es ajustable
Si ((leftStickX > = 1500) & & (leftStickX < = 1983)) {}
leftStickX = 1400;
}
}
Si no gatillos/sticks son móviles, luego centro y cero
Else {}
leftStickX = 1400;
smcSpeed = 0;
}
*** "LATIDO" RESERVADO ***
"Latido" enviará un comando serial cada segundos x como un "keep-alive" al SMC y JRK
Controladores. También evitará comandos duplicados de inundaciones el búfer serial (ideal
para la implementación de Xbee).
// *******************************
* COMANDOS SERIE ENVIAR *
// *******************************
/ * Reservado para comandos serie enviados a controladores de motor para ajustar
parámetros de la opción. También al proceso de la respuesta de los
comandos si procede. */
EN ESTA SECCIÓN ENVÍA LOS COMANDOS DE VELOCIDAD Y LA DIRECCIÓN AL SMC
// *******************************
* setMotorSpeed *
// *******************************
/*
http://www.Pololu.com/docs/0J44/6.2.1
El SMC Pololu puede utilizar un valor de velocidad de resolución (-3200 a 3200), sin embargo, esto no es necesario
(todavía) desde el controlador de Xbox de gatillos analógicos solamente salida de 0 a 255. El debajo de las tablas se copian
directamente desde el manual ligado por encima. Usaremos un valor de velocidad de baja resolución expresado en
porcentaje (0 a 100).
"Alternativo de interpretación: los valores permitidos para el segundo byte de datos de velocidad son 0à ¢ â' â €œ100,
así que usted puede ignorar el primer byte de datos de velocidad (siempre ponerlo a 0) y considerar la
segundo byte de datos que simplemente el porcentaje de velocidad. Por ejemplo, para conducir el motor en
53% en la velocidad, utilizas byte1 = 0 y byte2 = 53. "
Motor hacia delante
Comando Byte datos Byte 1 Byte 2 datos Byte 3 datos octeto de datos 4
Uso alterno de Pololu 0xAA (170) del dispositivo el número 0 x 05 (5) % de la velocidad 0 (siempre)
Marcha motor (cambios de datos byte 2)
Comando Byte datos Byte 1 Byte 2 datos Byte 3 datos octeto de datos 4
Uso alterno de Pololu 0xAA (170) del dispositivo el número 0 x 06 (6) % de la velocidad 0 (siempre)
*/
smcSpeed debe ser un número entre -100 y 100
Primero enviar el byte de comando de Pololu SMC
Serial.Write(pololuCommandByte);
A continuación, enviar el número de dispositivo SMC
Serial.Write(smcDeviceNumber);
Aquí, vamos a determinar la velocidad y dirección.
Si (smcSpeed < 0) / / vamos a atrás puesto que la velocidad es negativa
{
Serial.Write(6); comando reversa motor
smcSpeed = - smcSpeed; hacer smcSpeed positivos b y c el comando sólo puede leer números positivos
}
otra cosa
{
Serial.Write(5); comando del motor hacia adelante
}
Serial.Write(smcSpeedDataByte3); Siempre cero (por ahora) por el protocolo que se utiliza
Ahora vamos a enviar la velocidad real
Serial.Write(smcSpeed);
Delay(1); Para la estabilidad
SECCIÓN SIGUIENTE ENVÍA LA POSICIÓN DEL ACTUADOR LINEAR DE LA VÍA EL JRK
// *******************************
* setJRKPos *
// *******************************
/ * http://www.pololu.com/docs/0J38/4.e
Protocolo de Pololu, hexagonal: 0xAA, dispositivo número, 0 x 40 + objetivo baja 5 pedacitos, blanco alto 7 bits
Aquí es un código de ejemplo C que genere el seriales correcto bytes
dado un número entero "objetivo" que tiene el objetivo deseado (0 - 4095) y una matriz llamada serialBytes:
1 serialBytes [0] = 0xC0 + (destino & 0x1F); Byte de comando contiene los 5 bits más bajos del destino.
2 serialBytes [1] = (blanco >> 5) & 0x7F; Datos byte contiene los bits 7 superiores de destino. */
Serial.Write(pololuCommandByte);
Serial.Write(jrkDeviceNumber);
Serial.Write (0 x 40 + (leftStickX & 0x1F));
Serial.Write ((leftStickX >> 5) & 0x7F);
Delay(1); Para la estabilidad
}
