Simple RC Car pour les débutants (Android contrôle sur Bluetooth) 10 étapes (avec photos)

Introduction: Simple RC Car pour les débutants (Android contrôle sur Bluetooth)

Ceci est un projet simple de voiture Android Bluetooth avec contrôle Bluetooth. Contrôleur Arduino est utilisé

Pour contrôler la voiture d'occasion-appareil Android avec un accéléromètre intégré. Inclinaison vers l'avant - voiture va vers l'avant, l'inclinaison vers la gauche - la voiture tourne à gauche, inclinaison du dossier - voiture retourne. Vitesse de déplacement ou de rotation dépend de la quantité que vous inclinez l'appareil. La sensibilité et la valeur de l'inclinaison défini dans les applications-apps de configuration. Sont également fournis d'une manière normale à contrôler: les boutons à l'écran. En plus de tout ce que je mis en œuvre le contrôle tactile. Total 3 façons de contrôler la voiture RC.

Capacités de l'appareil que vous pouvez voir sur la vidéo ci-dessus

Etape 1: Dispositif Applications

Étape 2: DIY voiture châssis

Nous devons également tous les châssis avec 2 ou 4 moteurs à courant continu. Vous pouvez utiliser une vieille voiture de jouet RC. En tant que plate-forme que j'ai utilisé une petite plate-forme RC bricolage, acheté sur AliExpress pour 25 $. Il est le châssis de la piste le plus approprié pour ce projet.

Etape 3: Le contrôleur (MCU)

Vous avez besoin d'un contrôleur compatible Arduino (Nano, Uno, Leonardo, Mini et autres)

Le contrôleur doit contenir 2 PWM et UART.

Étape 4: Module Bluetooth

En tant que module Bluetooth utilise le module Bluetooth de série chinois pas cher HC-06 (3-4 $ sur AliExpress). Manuel d'instructions sur la connexion module Bluetooth à Arduino est ici.
Vous pouvez utiliser HC-05, HC-07 et d'autres modules Bluetooth série

Étape 5: Pilote du moteur

Je L298N double pont module de commande de moteur pas à courant continu. Il coûte 3-5 $ sur AliExpress.

Étape 6: Autres pièces

Étape 7: Théorie

Tous les calculs sont effectués dans l'applications à l'application, et de calculer immédiatement les valeurs 2 <2 L-255 \ rr-120 \ r
L - la commande du moteur gauche, R - pour le droit
Un tiret signifie que la rotation du moteur pour se déplacer en arrière
255 - valeur PWM (pour Arduino est la vitesse maximale de rotation)
\ R - fin de commande.
Sur cette commande RC voiture se déplace vers l'avant et légèrement tourné vers la droite, comme moteur droit tourne lentement à gauche.

L255 \ rr-255 \ r
Sur cette commande le moteur gauche tourne en arrière et en avant droit, ce qui oblige une voiture à tourner autour de son axe dans le sens antihoraire.

H1 \ r
La commande est un canal supplémentaire auquel vous pouvez connecter par exemple les lumières, le son, etc.

Symboles commande L, R et H peuvent être définies dans les paramètres des applications-Applications.

Dans le programme de commande MCU fournit une minuterie qui coupe le moteur si la dernière commande a été reçue il y a plus de n secondes. Les données sont stockées dans la mémoire EEPROM de l'unité de commande et peuvent être modifiées à partir du dispositif applications. La gamme de ce paramètre est de 0,1 secondes à 99,9 secondes. Ce réglage peut être désactivé. Pour travailler avec EEPROM fournit des commandes: Fr - valeurs de lecture 2 <2

Schéma Voir photo ci-dessus

Étape 8: Application Android

Comme on peut le voir, l'Arduino se connecte au module Bluetooth et un pilote de moteur à deux ou quatre moteurs connectés.

L'application pour Android a été écrit dans Eclipse IDE. Toutes les sources du projet et le projet Eclipse, vous pouvez télécharger ci-dessous. version Android sur votre appareil doit être> 3.0.

L'application contient plusieurs activités. Activité principale est un écran d'accueil avec des boutons en cours d'exécution différents modes de fonctionnement et réglages

Il y a 3 modes de contrôle Bluetooth voiture: de l'accéléromètre, boutons de l'écran tactile et le contrôle.

paramètres de l'application Android

Capture d'écran de paramètres CxemCar version de l'application Android 1.0

Pour établir une connexion avec le module Bluetooth de la voiture RC, vous devez définir l'adresse MAC dans les paramètres de l'application. Mais d'abord, vous devez configurer la paire des dispositifs sur-appareil Android: ouvrez Paramètres -> Bluetooth et cliquez sur « Rechercher des périphériques ». Lorsque le téléphone trouve notre module Bluetooth, cliquez sur les et entrez le mot de passe pour l'appariement (généralement « 1234 »)

Pour en savoir-module Bluetooth adresse MAC possible de toute application, comme terminal Bluetooth. Pour ce faire, cliquez sur « Connecter un appareil - Secure » et dans la fenêtre qui, cliquez sur le bouton « Rechercher des appareils ». Logiciel sera scanne les périphériques Bluetooth et les affiche MAC adresse.

Etape 9: Arduino RC voiture Câblage

Schéma de raccordement pour le contrôleur Arduino

Dans le circuit j'ai utilisé un cavalier (dans le schéma JMP1), car avec un module Bluetooth connecté est sketch charge impossible bé à l'Arduino.

J'ai soudé un module Bluetooth à l'Arduino et conduit le voyant d'état. Pour la communication entre Arduino et Bluetooth, lisez cet article: Arduino et Bluetooth. Module HC-06 placé dans le tube thermorétractable 10 mm. LED Bluetooth-état avec une résistance de limitation de courant (calculateur) ont également été placé dans un tube thermorétractable.

Dans la plate-forme de planche à pain, je percé un trou et d'entraînement de moteur sécurisé L298N. Arduino fixé avec du ruban adhésif double face

Entre la plate-forme de voiture et je breadboard placé 3 3.7V 1100 mAh batterie Li-Po. L'alimentation de l'unité de commande et des moteurs séparément: Arduino alimentés par une batterie de 3,7 V, et le moteur et pilote L298N de deux 3.7V batteries connectées en série. Il y a deux interrupteur 2 positions - une position est la puissance des batteries aux consommateurs, dans l'autre position aux bornes de charge.

Étape 10: Logiciel

Le programme a été écrit dans Arduino IDE 1.01.

#define D1 2 // sens de rotation du moteur 1
#define M1 3 // PWM gauche moteur
#define D2 4 // sens de rotation du moteur 2
#define M2 5 // PWM moteur droit
#define HORN 13 // canal supplémentaire 1
// # define AutoOff 2500 // millisecondes après que le robot s'arrête lorsque la connexion

'L' // UART-commande pour le moteur gauche #define cmdl
« R » // UART de commande pour le moteur droit #define CMdR
#define CMDh 'H' // UART-commande pour le canal supplémentaire (par exemple Horn)
#define CMDF 'F' // UART-commande pour le fonctionnement de l'EEPROM
#define Cmdr 'r' // UART-commande pour le fonctionnement de l'EEPROM (lire)
#define cmdw 'w' // UART-commande pour le fonctionnement de l'EEPROM (écriture)

incomingByte carbonisation; // données entrantes

carbonisation L_Data [4]; // données de tableau pour le moteur gauche
octet L_index = 0; // index du tableau L
carbonisation R_Data [4]; // données de tableau pour le moteur droit
octet R_index = 0; // index de la matrice R
carbonisation H_Data [1]; // données de matrice de canal supplémentaire
octet H_index = 0; // index de la matrice H
carbonisation F_Data [8]; // données de matrice de mémoire EEPROM
octet F_index = 0; // index du tableau F
commande de carbonisation; // commande

currentTime unsigned long, lastTimeCommand, AutoOff;

void setup () Serial.begin (9600); // initialisation UART
pinMode (HORN, OUTPUT); // canal supplémentaire
pinMode (D1, OUTPUT); // sortie de rotation du moteur
pinMode (D2, OUTPUT); // sortie de rotation du moteur
/*EEPROM.write(0,255);
EEPROM.write (1255);
EEPROM.write (2255);
EEPROM.write (3255); * /
timer_init (); // temporisateur logiciel d'initialisation
>

timer_init vide () uint8_t sw_autoOFF = EEPROM.read (0); // EEPROM lecture « est activée ou non l'arrêt de la voiture lorsque la perte de connexion »
if (sw_autoOFF == '1')< // if activated
carbonisation var_Data [3];
var_Data [0] = EEPROM.read (1);
var_Data [1] = EEPROM.read (2);
var_Data [2] = EEPROM.read (3);
AutoOff = atoi (var_Data) * 100; // AutoOff ms variables
>
else if (sw_autoOFF == '0')<
AutoOff = 999999;
>
else if (sw_autoOFF == 255) AutoOff = 2500; // si la mémoire EEPROM est vide, dafault valeur est de 2,5 sec
>
currentTime = Millis (); // lire le temps écoulé depuis le début de l'application
>

void loop () if (Serial.available ()> 0) < // if received UART data
incomingByte = Serial.read (); // octet raed
if (incomingByte == CMDL) < // if received data for left motor L
command = CMDL; // commande en cours
memset (L_Data, 0, sizeof (L_Data)); // tableau clair
L_index = 0; // réinitialisation index de tableau
>
else if (incomingByte == Cmdr) < // if received data for left motor R
command = CMdR;
memset (R_Data, 0, sizeof (R_Data));
R_index = 0;
>
else if (incomingByte == CMDh) < // if received data for additional channel
command = CMDh;
memset (H_Data, 0, sizeof (H_Data));
H_index = 0;
>
else if (incomingByte == FDMC) < // if received data for EEPROM op
command = CMDF;
memset (F_Data, 0, sizeof (F_Data));
F_index = 0;
>
else if (incomingByte == '\ r') command = 'E'; // fin de ligne
else if (incomingByte == '\ t') command = 't'; // fin de ligne op EEPROM

if (commande == cmdl - incomingByte = cmdl!) L_Data [L_index] = incomingByte; // stocker chaque octet de la matrice
L_index ++; // incrément index de tableau
>
else if (commande == Cmdr - incomingByte = Cmdr!) R_Data [R_index] = incomingByte;
R_index ++;
>
else if (commande == CMDh - incomingByte = CMDh!) H_Data [H_index] = incomingByte;
H_index ++;
>
else if (commande == FDMC - incomingByte = FDMC!) F_Data [F_index] = incomingByte;
F_index ++;
>
else if (commande == 'e')< // if we take the line end
Control4WD (atoi (L_Data), atoi (R_Data), atoi (H_Data));
retard (10);
>
else if (commande 't' ==)< // if we take the EEPROM line end
Flash_Op (F_Data [0], F_Data [1], F_Data [2], F_Data [3], F_Data [4]);
>
lastTimeCommand = Millis (); // lire le temps écoulé depuis le début de l'application
>
if (Millis ()> = (lastTimeCommand + AutoOff))< // compare the current timer with variable lastTimeCommand + autoOFF
Control4WD (0,0,0); // arrête la voiture
>
>

Control4WD vide (int mLeft, int mRight, uint8_t Horn)

bool directionL, directionR; // direction de L298N de rotation du moteur
octet valeurl, Evaluateur; // PWM M1, M2 (0-255)

if (mLeft> 0) = valeurl mLeft;
directionL = 0;
>
else if (mLeft < 0) valueL = 255 - abs(mLeft);
directionL = 1;
>
autre directionL = 0;
valeurl = 0;
>

if (mRight> 0) Evaluateur = mRight;
directionR = 0;
>
else if (mRight < 0) valueR = 255 - abs(mRight);
directionR = 1;
>
autre directionR = 0;
Evaluateur = 0;
>

analogWrite (M1, valeurl); // vitesse de consigne pour le moteur gauche
analogWrite (M2, Evaluateur); // vitesse de consigne pour le moteur droit
digitalWrite (D1, directionL); // direction de rotation de consigne du moteur gauche
digitalWrite (D2, directionR); // régler la direction de rotation du moteur droit

digitalWrite (HORN, Horn); // canal supplémentaire
>

annuler Flash_Op (char FCMD, z1 uint8_t, z2 uint8_t, z3 uint8_t, uint8_t z4)

Le code utilise une bibliothèque pour travailler avec EEPROM AVR-mémoire. Arduino par USART à partir du module Bluetooth reçoit des données prêt pour le moteur gauche et à droite. Tous les calculs de base sont effectués dans l'application Android.

La structure du projet dans Eclipse, vous pouvez voir sur la capture d'écran ci-dessus.

Vous pouvez télécharger le code source pour l'Arduino et le projet Eclipse
Télécharger l'application APK pour Android périphérique

La dernière version du logiciel se trouve sur cette page
Vidéo de démonstration du mode volant virtuel (version 1.2 et plus):

Post-scriptum Désolé pour mon mauvais anglais

Articles Liés

• simple voiture RC pour les débutants (contrôle Android via Bluetooth), Solderer TV

• Bluetooth Robot contrôlé à l'aide Arduino et Android, Into Robotics

• Casque Bluetooth DIY 6 étapes (avec photos)