Etape 1: Obtenir la manette Xbox, communiquer à l’Arduino
Brancher l’USB Host bouclier sur l’Arduino. Pour l’instant, pouvoir l’Arduino avec vous êtes ordinateur. Ensuite, branchez le Xbox 360™ Wireless Gaming Receiver for Windows®. Une fois que ces branchements code ci-dessous dans l’Arduino qui permet à l’Arduino effectuer des opérations de pilotage basées sur l’entrée du contrôleur de charge.
Il y a beaucoup de notation pour aider à comprendre ce qui se passe.
Code de l’Arduino
// ****************************** RC Power Wheels Jeep *
// *****************************
/*
VUE D’ENSEMBLE
Un ouragan 12v parmoteur Power Wheels Jeep aura en voiture
et volant télécommandé via Arduino.
MATÉRIEL
Puissance roues Jeep Hurricane
Arduino UNO R3
Circuits USB2.0 Host bouclier http://www.circuitsathome.com/products-page/arduino-shields/usb-host-shield-2-0-for-arduino
Contrôleur de moteur Simple Pololu 18v25 http://www.pololu.com/catalog/product/1381/resources
Contrôleur de moteur de JRK Pololu 12v12 http://www.pololu.com/catalog/product/1393/resources
Pololu linéaire générique actionneur 4".6"/s http://www.pololu.com/catalog/product/2333
Adaptateur USB sans fil Xbox 360
Manette sans fil Xbox 360
CONFIGURATION MATÉRIELLE
* +-------+ +---------------+ USB +-----------------+
* | Arduino +---> | USB Host bouclier +---> | USB de la XBOX Receiver| *** / >< / *** manette sans fil XBOX
* +-+-----+ +---------------+ +-----------------+
* |
* | TX (série TTL)
* |
* |------------------|
* | |
* v v Rx Rx
* +----------+ +----------+
* | SMC Pololu + | Pololu Jrk|
* +----------+ +----------+
* Maître esclave
* + +
* | |
* | |
* v v
* +--------+ +--------+
* | Double 12v| | Linéaires |
* | Moteurs | | Actuator|
* +--------+ +--------+
*
* NOTES
* À l’extérieur avec line-of-sight, la manette de Xbox sans fil dispose d’une gamme impressionnante. La gamme max
* n'a pas été entièrement testés, mais je suis allé plus de 50 pieds sans perte notable de signal.
*
* Tout se trouve à bord de la Jeep. Toutes les connexions série TTL sont câblées à l’Arduino
* et gradateurs. Le récepteur de Xbox est relié à une antenne de tringle en métal-style.
*
* L’actionneur linéaire actuel peut être trop lent. Il peut s’y installer de 110lbs de force mais à.6"/ s.
* est un modèle plus rapide qui fait 22lbs @ 1.5" /s http://www.pololu.com/catalog/product/2345
*
*/
*** Comprend pour le Circuits USB bouclier ***
#include < XBOXRECV.h > / / récepteur sans fil Xbox 360
Créer l’instance de l’USB ? BOUCLIER DE L’USB
USB Usb ;
Créez une instance du récepteur Xbox entrées appelées XboxRCV
XBOXRECV XboxRCV(&Usb) ; BOUCLIER DE L’USB
Ces constantes prochaines font partie d’octets du protocole Pololu
const byte pololuCommandByte = 170 ;
const byte smcDeviceNumber = 13 ;
const byte smcSpeedDataByte3 = 0 ;
const byte smcFWDbyte = 5 ;
const byte smcREVbyte = 6 ;
const byte jrkDeviceNumber = 11 ;
char smcSpeed ; Vitesse finale
long int leftStickX ; Valeur de Xbox Left Analog Stick
void setup() {}
Serial.Begin(9600) ; Bauds série à 9600
Stopper le programme jusqu'à ce que le bouclier est connecté
USB. Init renvoie -1 pour blindage débranché et 0 si connecté
Si (Usb.Init() == -1) {/ / bouclier USB si ne pas initialiser pour une raison quelconque...
while(1) ; coup d’arrêt tant que le bouclier est rapporté déconnecté
}
}
void loop() {}
Usb.Task() ;
Nous allons traiter l’entrée de Xbox
{if(XboxRCV.Xbox360Connected[0])}
Lancez le bouton envoie exitSafeStart commande à SMC
{if(XboxRCV.getButtonClick(Start,0))}
// *******************************
* exitSafeStart *
// *******************************
Nécessaire pour permettre à moteurs connectés SMC pour déplacer
Doit être appelé lors du redémarrage de contrôleur et après toute erreur
Pololu protocole : 0xAA (170) | Numéro de périphérique | 0 x 03 (3)
Serial.Write(pololuCommandByte) ;
Serial.Write(smcDeviceNumber) ;
Serial.Write(3) ;
}
/ * Les déclencheurs Xbox fournissent des valeurs de 0 - 255. Le SMC acceptera une faible
valeur de la vitesse de résolution sous forme de pourcentage, 0 % - 100 % (haute résolution est
un entier de 2 octets). Les deux lignes suivantes mappe le contrôleur à la sortie un
valeur négative pour la L2 (inverser) et positive pour R2 (Forward). Ces deux
les valeurs sont ensuite additionnés pour fournir la vitesse finale et la direction. Il s’agit
alors que les deux déclencheurs peuvent être tenus pour simultaneosly sans causer les valeurs
à osciller entre la marche avant et arrière
*/
char XboxL2 = map((XboxRCV.getButtonPress(L2,0)), 0, 255, 0 -100) ;
char XboxR2 = map((XboxRCV.getButtonPress(R2,0)), 0, 255, 0, 100) ;
Somme des entrées mappées ensemble pour donner une vitesse finale et une orientation
smcSpeed = XboxL2 + XboxR2 ;
/ * L’exemple de code pour la manette Xbox a donné une zone morte de-7500 à 7500.
Ce code gère cette zone morte pour l’instant (je tiens à faire
réglable tandis que l’esquisse est en cours d’exécution). */
leftStickX = map(XboxRCV.getAnalogHat(LeftHatX,0), -32768, 32767, 3880, 0) ; Stick analogique déplacé
Définissez la bande morte dans le stick analogique gauche. Tiens c’est réglable
Si ((leftStickX > = 1500) & & (leftStickX < = 1983)) {}
leftStickX = 1400 ;
}
}
Si aucun déclencheurs/bâtons ne sont en mouvement, puis Centrez et zéro
else {}
leftStickX = 1400 ;
smcSpeed = 0 ;
}
*** RÉSERVÉE « HEARTBEAT » ***
« Heartbeat » enverra une commande de série toutes les x secondes comme un « keep-alive » à la SMC et JRK
contrôleurs. Il empêchera également en double commandes contre les inondations le tampon série (idéal
Xbee mise en œuvre).
// *******************************
* COMMANDES DE SÉRIE ENVOI *
// *******************************
/ * Réservée aux commandes série envoyés aux contrôleurs de moteurs pour ajuster
paramètres d’option. Aussi pour traiter la réponse de celles
commandes, le cas échéant. */
CETTE SECTION ENVOIE LES COMMANDES DE VITESSE ET LA DIRECTION DE LA SMC
// *******************************
* setMotorSpeed *
// *******************************
/*
http://www.Pololu.com/docs/0J44/6.2.1
Le SMC Pololu pouvez utiliser une valeur de vitesse pleine résolution (-3200 à 3200), cependant, cela n’est pas nécessaire
(encore) depuis la manette Xbox gâchettes analogiques seulement sortie 0 à 255. Les dessous de tables sont copiés
directement à partir du manuel lien ci-dessus. Nous allons utiliser une valeur de vitesse de basse résolution exprimée en
pourcentage (de 0 à 100).
"Remplaçant l’interprétation : les valeurs autorisées pour le deuxième octet de données de vitesse sont 0à ¢ â'¬â €œ100,
alors vous pouvez ignorer le premier octet de données de vitesse (toujours définissez-la sur 0) et d’envisager la
deuxième octet de données d’être simplement le pourcentage de la vitesse. Par exemple, pour entraîner le moteur à
53 % de la vitesse, vous utiliseriez octet1 = 0 et octet2 = 53. »
Moteur en marche avant
Commande octets données octet 1 données octet 2 données octet 3 octet de données 4
Numéro de périphérique Pololu autre utilisation 0xAA (170) 0 x 05 (5) la vitesse (toujours) 0 %
Moteur arrière (modifications de données octet 2)
Commande octets données octet 1 données octet 2 données octet 3 octet de données 4
Numéro de périphérique Pololu autre utilisation 0xAA (170) 0 x 06 (6) la vitesse (toujours) 0 %
*/
smcSpeed doit être un nombre compris entre -100 et 100
Tout d’abord envoyer l’octet de commande Pololu SMC
Serial.Write(pololuCommandByte) ;
Ensuite, envoyez le numéro de périphérique SMC
Serial.Write(smcDeviceNumber) ;
Ici, nous allons déterminer la vitesse et la direction.
Si (smcSpeed < 0) / / nous allons inverser puisque la vitesse est négative
{
Serial.Write(6) ; commande de marche arrière moteur
smcSpeed = - smcSpeed ; faire smcSpeed positif b/c, la commande peut uniquement lire des nombres positifs
}
d’autre
{
Serial.Write(5) ; moteur avant commande
}
Serial.Write(smcSpeedDataByte3) ; Toujours zéro (pour l’instant) en raison du protocole utilisé
Maintenant nous allons envoyer la vitesse réelle
Serial.Write(smcSpeed) ;
Delay(1) ; Pour la stabilité
SECTION SUIVANTE ENVOIE LA POSITION DE L’ACTIONNEUR LINÉAIRE VIA LE JRK
// *******************************
* setJRKPos *
// *******************************
/ * http://www.pololu.com/docs/0J38/4.e
Protocole Pololu, hex : 0xAA, dispositif numéro, 0 x 40 + cible 5 bits de poids faible, cibler les bits de poids fort 7
Voici des exemples C de code qui va générer les octets séries correctes,
étant donné un entier « cible », qui contient la cible souhaitée (0 - 4095) et un tableau intitulé serialBytes :
1 serialBytes [0] = 0xC0 + (cible & 0x1F) ; Octet de commande contient les 5 bits de poids faible de cible.
2 serialBytes [1] = (cible >> 5) & 0x7F ; Données octet contient les bits 7 supérieurs de cible. */
Serial.Write(pololuCommandByte) ;
Serial.Write(jrkDeviceNumber) ;
Serial.Write (0 x 40 + (leftStickX & 0x1F)) ;
Serial.Write ((leftStickX >> 5) & 0x7F) ;
Delay(1) ; Pour la stabilité
}
