Comment faire un robot de contrôle gestuel à la maison

//programme modifié le 10/03/19 par // par Shubham Shinganapure.
//
//pour Voiture robotique à commande gestuelle (télécommande)
#include " I2Cdev.h"
#include "MPU6050_6Axis_MotionApps20.h"
//#include "MPU6050.h" // pas nécessaire si vous utilisez MotionApps include file
// La bibliothèque Arduino Wire est requise si I2Cdev Implémentation I2CDEV_ARDUINO_WIRE
// est utilisé dans I2Cdev.h
#if I2CDEV_IMPLEMENTATION ==I2CDEV_ARDUINO_WIRE
#include "Wire.h"
#endif
// classe I2C par défaut l'adresse est 0x68
// des adresses I2C spécifiques peuvent être passées en paramètre ici
// AD0 low =0x68 (par défaut pour SparkFun breakout et la carte d'évaluation InvenSense)
// AD0 high =0x69
MPU6050 mpu;
#define OUTPUT_READABLE_YAWPITCHROLL
// vars de contrôle/statut MPU
bool dmpReady =false ; // défini sur true si l'initialisation DMP a réussi
uint8_t mpuIntStatus; // contient l'octet d'état d'interruption réel du MPU
uint8_t devStatus ; // renvoie l'état après chaque opération de périphérique (0 =succès, !0 =erreur)
uint16_t packetSize; // taille de paquet DMP attendue (la valeur par défaut est de 42 octets)
uint16_t fifoCount; // compte de tous les octets actuellement dans FIFO
uint8_t fifoBuffer[64]; // Tampon de stockage FIFO
VectorFloat Gravity;
Quaternion q;
float ypr[3]; // [lacet, tangage, roulis] conteneur lacet/tangage/rouleau et vecteur de gravité
uint8_t teapotPacket[14] ={ '$', 0x02, 0,0, 0,0, 0,0, 0,0 , 0x00, 0x00, '\r', '\n' };
volatile bool mpuInterrupt =false; // indique si la broche d'interruption MPU est devenue haute
void dmpDataReady() {
mpuInterrupt =true;
}
#include 
SoftwareSerial BTSerial( 10, 11); // Réception | TX
int bt=8;
int x =1;
void setup() {
#if I2CDEV_IMPLEMENTATION ==I2CDEV_ARDUINO_WIRE
Wire.begin();
TWBR =24 ; // Horloge I2C 400kHz (200kHz si CPU est à 8MHz)
#elif I2CDEV_IMPLEMENTATION ==I2CDEV_BUILTIN_FASTWIRE
Fastwire::setup(400, true);
#endif
// initialiser série communication
// (115200 choisi car requis pour la sortie Teapot Demo, mais c'est
// vraiment à vous en fonction de votre projet)
Serial.begin(115200);
BTSerial.begin(38400);
// while (!Serial); // attendre l'énumération Leonardo, les autres continuent immédiatement
Serial.println(F("Initializing I2C devices..."));
mpu.initialize();
// vérifier la connexion
Serial.println(F("Test des connexions de l'appareil..."));
Serial.println(mpu.testConnection() ? F("Connexion MPU6050 réussie") :F("Echec de la connexion MPU6050" ));
// attendre prêt
// charger et configurer le DMP
Serial.println(F("Initializing DMP..."));
devStatus =mpu .dmpInitialize();
// fournissez vos propres décalages de gyroscope ici, mis à l'échelle pour une sensibilité minimale
mpu.setXGyroOffset(220);
mpu.setYGyroOffset(76);
mpu. setZGyroOffset(-85);
mpu.setZAccelOffset(1788) ;
// assurez-vous que cela a fonctionné (renvoie 0 si oui)
if (devStatus ==0) {
/ / activer le DMP, maintenant qu'il est prêt
Serial.println(F("Enabling DMP..."));
mpu.setDMPEnabled(true);
//activer l'interruption Arduino détection
Serial.println(F("Activation de la détection d'interruption (interruption externe Arduino 0)..."));
a ttachInterrupt(0, dmpDataReady, RISING);
mpuIntStatus =mpu.getIntStatus();
// définir notre indicateur DMP Ready pour que la fonction principale loop() sache qu'il est possible de l'utiliser
Serial .println(F("DMP prêt ! En attente de la première interruption..."));
dmpReady =true;
// obtenir la taille de paquet DMP attendue pour une comparaison ultérieure
packetSize =mpu.dmpGetFIFOPacketSize();
} else {
// ERREUR !
// 1 =échec du chargement initial de la mémoire
// 2 =échec des mises à jour de la configuration DMP
// (en cas de panne, généralement le code sera 1)
Serial.print(F("DMP Initialization failed (code "));
Serial.print(devStatus);
Serial.println(F(")"));
}
// configurer la LED pour la sortie
pinMode(bt,INPUT);
}
// =================================================================
// ===BOUCLE DE PROGRAMME PRINCIPAL ===
// ================================================================
boucle vide() {
 if(digitalRead(bt)==HIGH)
{
x++;
delay(150);
}
if((x%2)==0) {
// si la programmation a échoué, n'essayez pas de faire quoi que ce soit
si (!dmpReady) revient ;
// attendez l'interruption du MPU ou des paquets supplémentaires disponibles
 while (!mpuInterrupt &&fifoCount // d'autres trucs sur le comportement du programme ici
// .
// .
// .
// si vous êtes vraiment paranoïaque, vous pouvez fréquemment tester entre d'autres
// trucs pour voir si mpuInterrupt est vrai, et si c'est le cas, "break;" de la boucle
// while() pour traiter immédiatement le MPU data
// .
// .
// .
}
// réinitialiser l'indicateur d'interruption et obtenir l'octet INT_STATUS
mpuInterrupt =false ;
mpuIntStatus =mpu.getIntStatus();
// obtenir le compte FIFO actuel
fifoCount =mpu.getFIFOCount();
// vérifier le débordement (cela ne devrait jamais arriver à moins que notre code ne soit trop inefficace)
if ((mpuIntStatus &0x10) || fifoCount ==1024) {
// réinitialiser afin que nous puissions continuer proprement
mpu.resetFIFO();
Serial.println(F("FIFO overflow !"));
 // sinon, vérifiez l'interruption de la disponibilité des données DMP (cela devrait se produire fréquemment)
} else if (mpuIntStatus &0x02) {
// attendez la longueur correcte des données disponibles, devrait être une attente TRÈS courte
 while (fifoCount // lire un paquet depuis FIFO
mpu.getFIFOBytes(fifoBuffer, packetSize);
// suivre le nombre FIFO ici au cas où il y aurait> 1 paquet disponible
// (cela nous permet d'en lire plus immédiatement sans attendre une interruption)
fifoCount -=packetSize;
#ifdef OUTPUT_READABLE_YAWPITCHROLL
// display Angles d'Euler en degrés
mpu.dmpGetQuaternion(&q, fifoBuffer);
mpu.dmpGetGravity(&gravity, &q);
mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
Série .print("ypr\t");
Serial.print(ypr[0] * 180/M_PI);
Serial.print("\t");
Serial.print( ypr[1] * 180/M_PI);
Série .print("\t");
Série.println(ypr[2] * 180/M_PI);
if((ypr[1] * 180/M_PI)<=-25)
{BTSerial.write('F');
}
else if((ypr[1] * 180/M_PI)>=25)
{BTSerial.write('B' );
}
else if((ypr[2] * 180/M_PI)<=-25)
{BTSerial.write('L');
}
else if((ypr[2] * 180/M_PI)>=20)
{BTSerial.write('R');
}
else{
BTSerial. write('S');
}
#endif
}
}
else{
BTSerial.write('S');
}
} 

Insérez le module Bluetooth esclave sur l'unité de voiture et maîtrisez le module Bluetooth sur l'unité distante. Et tout est fait.

Allumons-le et il est prêt à jouer…….

Espérant que ceci puisse t'être utile. si oui, aimez-le, partagez-le, commentez votre doute. Pour plus de tels projets, suivez-moi! Soutenez mon travail et abonnez-vous à ma chaîne sur YouTube.

Merci !