Projet 17 : Char d’assaut contrôlé par Bluetooth
(1)Description :
Nous avons appris les connaissances de base sur le Bluetooth dans le projet précédent. Dans cette leçon, nous allons utiliser le Bluetooth pour contrôler la voiture intelligente. Puisqu’il s’agit de Bluetooth, un émetteur et un récepteur sont nécessaires. Dans ce projet, nous utilisons le téléphone mobile comme émetteur (maître), et la voiture intelligente connectée au module Bluetooth HM-10 (esclave) comme récepteur.
Nous avons appris précédemment qu’envoyer un bit peut contrôler des LED. Le principe de contrôle de ce robot roulant est le même.
Nous allons d’abord comprendre la fonction de chaque bouton sur l’application, puis utiliser les boutons de l’application pour contrôler le char.
(2)Fonctions principales des boutons de l’application
Le tableau suivant illustre les fonctions des touches correspondantes :
TOUCHES |
FONCTIONS |
|---|---|
|
Associer et connecter le module Bluetooth HM-10 ; cliquer à nouveau pour déconnecter |
|
Sélectionner le robot à utiliser |
|
Contrôler les mouvements du robot par boutons |
|
Contrôler les mouvements du robot par joystick |
|
Contrôler les mouvements du robot par gravité |
|
Envoie “F” lorsqu’appuyé et “S” lorsque relâché |
|
Envoie “L” lorsqu’appuyé et “S” lorsque relâché |
|
Envoie “R” lorsqu’appuyé et “S” lorsque relâché |
|
Envoie “B” lorsqu’appuyé et “S” lorsque relâché |
|
Envoie “u”+chiffre+“#” lorsqu’on fait glisser |
|
Envoie “v”+chiffre+“#” lorsqu’on fait glisser |
|
Sélectionner pour accéder à la page des fonctions |
|
Envoie “G” lorsqu’appuyé et “S” lorsqu’appuyé à nouveau |
|
Envoie “h” lorsqu’appuyé et “S” lorsqu’appuyé à nouveau |
|
Envoie “e” lorsqu’appuyé et “S” lorsqu’appuyé à nouveau |
|
Envoie “f” lorsqu’appuyé et “S” lorsqu’appuyé à nouveau |
|
Envoie “i” lorsqu’appuyé et “S” lorsqu’appuyé à nouveau |
|
Envoie “j” lorsqu’appuyé et “S” lorsqu’appuyé à nouveau |
|
Sélectionner pour accéder au mode d’affichage d’expressions faciales |
|
Envoie “k” lorsqu’appuyé et “z” lorsqu’appuyé à nouveau |
|
Envoie “l” lorsqu’appuyé et “z” lorsqu’appuyé à nouveau |
|
Envoie “m” lorsqu’appuyé et “z” lorsqu’appuyé à nouveau |
|
Envoie “n” lorsqu’appuyé et “z” lorsqu’appuyé à nouveau |
|
Envoie “o” lorsqu’appuyé et “z” lorsqu’appuyé à nouveau |
|
Envoie “p” lorsqu’appuyé et “z” lorsqu’appuyé à nouveau |
|
Choisir pour accéder à l’interface de fonctions personnalisées ; il y a six touches 1,2,3,4,5,6 ; avec ces touches, vous pouvez développer certaines fonctions par vous-même |
|
Cliquer pour envoyer “w” |
|
Cliquer pour envoyer “y” |
|
Cliquer pour envoyer “x” |
|
Cliquer pour envoyer “c”, cliquer à nouveau pour envoyer “d” |
(3)Organigramme :
(4)Schéma de câblage :
Les broches GND, VCC, SDA et SCL de la matrice de points LED 8x16 sont respectivement connectées à -(GND), +(VCC), SDA, SCL de la carte d’extension ;
Les broches STATE et BRK du module Bluetooth n’ont pas besoin d’être connectées.
(5)Code de test :
(Remarque : Lors du téléversement du code, le module Bluetooth doit être débranché, et le Bluetooth peut être reconnecté après le processus de téléversement. Sinon, le code pourrait ne pas être téléversé avec succès.)
/*
Keyestudio Mini Tank Robot V3 (Popular Edition)
lesson 17.
bluetooth Control tank
http://www.keyestudio.com
*/
// Tableau, utilisé pour sauvegarder les données des images, peut être calculé manuellement ou obtenu via un outil de modulation
unsigned char start01[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
unsigned char front[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x12, 0x09, 0x12, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
unsigned char back[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x48, 0x90, 0x48, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
unsigned char left[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x28, 0x10, 0x44, 0x28, 0x10, 0x44, 0x28, 0x10, 0x00};
unsigned char right[] = {0x00, 0x10, 0x28, 0x44, 0x10, 0x28, 0x44, 0x10, 0x28, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
unsigned char STOP01[] = {0x2E, 0x2A, 0x3A, 0x00, 0x02, 0x3E, 0x02, 0x00, 0x3E, 0x22, 0x3E, 0x00, 0x3E, 0x0A, 0x0E, 0x00};
unsigned char clear[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
#define SCL_Pin A5 // Définir la broche d'horloge comme A5
#define SDA_Pin A4 // Définir la broche de données comme A4
#define ML_Ctrl 4 // Définir la broche de contrôle de direction du moteur gauche
#define ML_PWM 6 // Définir la broche de contrôle PWM du moteur gauche
#define MR_Ctrl 2 // Définir la broche de contrôle de direction du moteur droit
#define MR_PWM 5 // Définir la broche de contrôle PWM du moteur droit
char ble_val; // Utilisé pour stocker la valeur obtenue par Bluetooth
void setup()
{
Serial.begin(9600);
pinMode(ML_Ctrl, OUTPUT);
pinMode(ML_PWM, OUTPUT);
pinMode(MR_Ctrl, OUTPUT);
pinMode(MR_PWM, OUTPUT);
pinMode(SCL_Pin, OUTPUT);
pinMode(SDA_Pin, OUTPUT);
matrix_display(clear); // Effacer l'écran
matrix_display(start01); // Afficher l'image de démarrage
}
void loop()
{
if (Serial.available())
{
ble_val = Serial.read();
Serial.println(ble_val);
}
switch (ble_val)
{
case 'F': // Commande pour avancer
Car_front();
break;
case 'B': // Commande pour reculer
Car_back();
break;
case 'L': // Commande pour tourner à gauche
Car_left();
break;
case 'R': // Commande pour tourner à droite
Car_right();
break;
case 'S': // Commande pour s'arrêter
Car_Stop();
break;
}
}
/***************Fonction pour faire fonctionner le moteur***************/
void Car_back()
{
digitalWrite(MR_Ctrl, LOW);
analogWrite(MR_PWM, 200);
digitalWrite(ML_Ctrl, LOW);
analogWrite(ML_PWM, 200);
matrix_display(back); // Reculer
}
void Car_front()
{
digitalWrite(MR_Ctrl, HIGH);
analogWrite(MR_PWM, 55);
digitalWrite(ML_Ctrl, HIGH);
analogWrite(ML_PWM, 55);
matrix_display(front); // Afficher l'image pour avancer
}
void Car_left()
{
digitalWrite(MR_Ctrl, HIGH);
analogWrite(MR_PWM, 55);
digitalWrite(ML_Ctrl, LOW);
analogWrite(ML_PWM, 200);
matrix_display(left); // Afficher l'image pour tourner à gauche
}
void Car_right()
{
digitalWrite(MR_Ctrl, LOW);
analogWrite(MR_PWM, 200);
digitalWrite(ML_Ctrl, HIGH);
analogWrite(ML_PWM, 55);
matrix_display(right); // Afficher l'image pour tourner à droite
}
void Car_Stop()
{
digitalWrite(MR_Ctrl, LOW);
analogWrite(MR_PWM, 0);
digitalWrite(ML_Ctrl, LOW);
analogWrite(ML_PWM, 0);
matrix_display(STOP01); // Afficher l'image d'arrêt
}
// Cette fonction est utilisée pour l'affichage sur l'écran à matrice de points
void matrix_display(unsigned char matrix_value[])
{
IIC_start(); // Fonction pour appeler la condition de démarrage du transfert de données
IIC_send(0xc0); // Choisir une adresse
for (int i = 0; i < 16; i++) // Les données de motif ont 16 octets
{
IIC_send(matrix_value[i]); // Transférer les données du motif
}
IIC_end(); // Terminer le transfert des données du motif
IIC_start();
IIC_send(0x8A); // Contrôle d'affichage, sélectionner la largeur d'impulsion à 4/16
IIC_end();
}
// Conditions pour le début du transfert de données
void IIC_start()
{
digitalWrite(SDA_Pin, HIGH);
digitalWrite(SCL_Pin, HIGH);
delayMicroseconds(3);
digitalWrite(SDA_Pin, LOW);
delayMicroseconds(3);
digitalWrite(SCL_Pin, LOW);
}
// Signe de fin de transmission de données
void IIC_end()
{
digitalWrite(SCL_Pin, LOW);
digitalWrite(SDA_Pin, LOW);
delayMicroseconds(3);
digitalWrite(SCL_Pin, HIGH);
delayMicroseconds(3);
digitalWrite(SDA_Pin, HIGH);
delayMicroseconds(3);
}
// Transférer des données
void IIC_send(unsigned char send_data)
{
for (byte mask = 0x01; mask != 0; mask <<= 1) // Chaque caractère a 8 chiffres, détectés un par un
{
if (send_data & mask) // Définir des niveaux hauts ou bas en fonction de chaque bit (0 ou 1)
{
digitalWrite(SDA_Pin, HIGH);
}
else
{
digitalWrite(SDA_Pin, LOW);
}
delayMicroseconds(3);
digitalWrite(SCL_Pin, HIGH); // Mettre la broche d'horloge SCL_Pin à l'état haut pour arrêter la transmission de données
delayMicroseconds(3);
digitalWrite(SCL_Pin, LOW); // Mettre la broche d'horloge SCL_Pin à l'état bas pour changer les signaux de SDA
}
}
(6)Résultat du test :
Après avoir téléversé le code, connectez le robot au module Bluetooth et associez l’application Bluetooth. Allumez l’interrupteur d’alimentation du bouclier de commande de moteur. Placez le robot sur le sol, vous pouvez utiliser ces boutons de l’application Bluetooth pour contrôler le robot.
Les flèches haut, bas, gauche et droite contrôlent respectivement le robot pour avancer, reculer, aller à gauche et aller à droite.
Cliquez sur le bouton joystick et tirez la direction du point noir dans le cercle blanc pour contrôler la direction de déplacement du robot.
Cliquez sur le bouton Gravité et inclinez le téléphone dans les directions avant, arrière, gauche et droite, et le robot se déplacera dans la direction dans laquelle le téléphone est incliné.
