Très souvent, dans vos projets, vous avez besoin d'un contrôle à distance ou d'un transfert de données depuis vos gadgets téléphoniques.

L'une des méthodes d'échange de données les plus populaires et les plus répandues via Bluetooth .

Aujourd'hui, nous allons examiner des exemples simples sur la façon de connecter Bluetooth module à Arduino et configurez la télécommande depuis votre téléphone.

Nous aurons besoin:

• Jeu de fils MALE-MAMA
  
• HC-06 Bluetooth
  

Connectez Bluetooth Le module du microcontrôleur Arduino est plus pratique en utilisant un câblage MALE-MAMALE.

Arduino	Bluetooth
Broche 1 (TX)	RXD
Broche 0 (RX)	TXD
GND	GND
5V	VCC

Attention, vous devez vous connecter Émission -> RXD ,RX -> TXD .

Vous devez maintenant écrire le code de test du programme :

Lors du chargement du sketch, il faut que le module Bluetooth soit déconnecté du microcontrôleur arduino. Sinon, le croquis ne sera pas enregistré car la connexion avec Bluetooth Le module communique via les mêmes ports RX et TX que l'USB.

Val int; LED int = 13 ; void setup() ( Serial.begin(9600); pinMode(LED, OUTPUT); digitalWrite(LED, HIGH); ) void loop() ( if (Serial.available()) ( val = Serial.read(); / / Lorsque le caractère est "1", allumez la LED if (val == "1") ( digitalWrite(LED, HIGH); ) // Lorsque le caractère est "0", éteignez la LED if (val == "0") ( digitalWrite(LED, FAIBLE); ) ) )

Une fois le croquis enregistré et Bluetooth Le module est connecté à l'Arduino, vous pouvez passer à l'étape suivante.

Connexion Bluetooth à votre téléphone

Il est conseillé d'utiliser non pas l'USB comme source d'alimentation pour arduino, mais une alimentation externe 9 V.

1. Activez Bluetooth sur votre téléphone et recherchez de nouveaux appareils
2. On retrouve dans la liste des troubles " HC-06" et connectez-vous à lui.
3. Le téléphone demandera un code PIN. vous devez entrer " 1234 " ou " 0000 "
4. Hourra. L'appareil est connecté.

Vous devez maintenant télécharger le terminal Bluetooth sur votre téléphone. Nous prendrons l'exemple de la plateforme Android.

Vous pouvez installer différents terminaux Bluetooth, en règle générale, ils ne diffèrent que par des conceptions différentes, la fonctionnalité ne change pas. Vous pouvez également trouver un terminal pour les produits iOS.

Après avoir installé le terminal, nous le lançons, sélectionnons notre module Bluetooth HC-06 et nous nous y connectons.

Il est temps de tester le projet en action. Nous écrivons le chiffre « 0 » dans le terminal et envoyons. La LED L qui se trouve sur la carte Arduino à côté de la broche 13 devrait s'éteindre. Maintenant, nous envoyons le chiffre « 1 » via le terminal et la LED L devrait s'allumer.

Démonstration de travail :

Devoirs:

• Modifiez le croquis pour que la LED s'allume et s'éteigne en utilisant la même commande, par exemple « G ».
• Complétez le croquis et apprenez-lui à convertir les données texte provenant via Bluetooth en données numériques et implémentez un dimère, allumez une LED en utilisant PWM, à une luminosité donnée de 0 à 254 provenant via Bluetooth.

Une histoire détaillée de la façon dont une machine a été assemblée à partir de trois moteurs sur Arduino, contrôlés par un appareil Android via Bluetooth. En plusieurs dizaines de paragraphes, je vais essayer d'expliquer le plus étape par étape possible où connecter chacun des fils, comment écrire une application propriétaire et sur quel type de râteau pour enfants j'ai dû sauter pendant plus d'une semaine.

Un peu sur le niveau, l'auteur et les avertissements

Moi, l'auteur, un garçon de 16-17 ans originaire d'un village près de Moscou, je suis spécialisé dans l'écriture d'applications Android (et il est plus difficile d'y graver quelque chose), je me décharge donc de la responsabilité de l'approche optimale pour résoudre les problèmes.

Tâche

La tâche la plus simple consiste à faire rouler une voiture contrôlée par Arduino et à remplacer la télécommande par un Android. Mais dans la plupart des cas, nous avons dû réinventer la roue, car aucune solution adaptée n’a été trouvée sur Internet.

Aura besoin

1. Arduino
2. Bouclier moteur (dans mon cas deux)
3. Bluetooth
4. Android
5. Les fils sont ordinaires

Base de conception

La voiture Lego Outdoor Challenger a été prise comme base (en réalité elle a l'air moins prétentieuse). Il n'en reste que la carrosserie (tous les éléments décoratifs ont été supprimés) et trois moteurs.

La machine avait sa propre carte, mais une des tâches impliquait de la polyvalence : je l'ai fait, d'autres peuvent le faire. J'ai sorti mon cerveau et installé Arduino Uno.

Installation d'Arduino

Pour une raison quelconque, les créateurs n'ont pas prévu de place pour l'Arduino, ils l'ont donc fixé avec des vis, en perçant le plastique. J'ai placé du contreplaqué sous la planche pour que rien ne court-circuite. Il est préférable de glisser quelque chose de plastique (un morceau de bouteille) sous les vis, car la planche n'est pas protégée des boulons en fer.

J’ai immédiatement installé deux blindages moteur sur le dessus de la carte, c’est comme ça que c’est censé être. Pour contrôler le second, vous devrez connecter un fil de n'importe quel port numérique à H1 (direction) et le second d'une broche avec support de cale (marquée d'un signe « ~ », généralement 10, 11) à E1 (vitesse). .

Détermination de l'angle de rotation

Étonnamment, ce n'est pas le servomoteur qui est chargé de faire tourner la voiture, mais un moteur ordinaire. Un problème se pose : ce serait bien de ne pas le brûler, car l'angle de rotation est limité, et le moteur peut tourner autant qu'il le souhaite.

L'option de la méthode poke est éliminée, car avec différents niveaux de batterie, la quantité de courant fournie au moteur changera, ce qui entraînera un angle en constante évolution. Vous ne pouvez pas non plus le tourner à fond, tôt ou tard les engrenages s'effondreront.

La solution au problème consiste à suivre l’angle à travers la fermeture. La photo montre une petite chose qui est fixée près du mécanisme rotatif. Un peigne avec des contacts en fer est fixé sur la partie qui tourne avec les roues gauche/droite du moteur.

Principe de fonctionnement : un fil est soudé à chaque ligne (il y en a quatre au total), celui du bas est relié au positif (il est toujours serré avec un peigne, voir photo), les fils restants vont au négatif. Lorsqu'une dent de peigne touche à la fois la rangée du bas et, disons, la troisième, un court-circuit se produit, le courant circule et Arduino le remarque.

Grâce aux différentes combinaisons des trois bandes, jusqu'à sept coins peuvent être définis. Par exemple, lorsqu'il y a du courant sur toutes les lignes, les roues sont tournées à l'extrême droite, lorsqu'il n'y a du courant qu'en haut, les roues sont tournées le plus possible vers la gauche. Le tableau fournit toutes les options.

Connexion d'angle et code

Pour chaque niveau, une couleur différente a été choisie : celle du bas est verte, la première en partant du bas est rouge, la deuxième est noire, la troisième est blanche. Au stade initial, une maquette et des LED ont été utilisées pour le débogage visuel.

Le schéma de connexion est présenté sur la figure. De plus, nous tirons vers le vert, le reste nous étirons vers le moins. Grâce à une résistance installée pour éliminer les interférences et éviter les courts-circuits, nous connectons les fils aux sorties A0-A2. Ils ont été choisis simplement pour sauver d'autres ports.

Le code est donné avec des commentaires. Nous connectons les broches et les interrogeons via digitarRead(). S'il y a une tension, true sera renvoyé. Ensuite, nous regardons, si le résultat signifie que les roues sont dans des positions extrêmes, nous interdisons toute rotation ultérieure dans cette direction.

Petite astuce : puisque des sorties 5V et 3,3V seront nécessaires à l'avenir, vous pouvez mettre un plus sur l'une des broches numériques. Avant chaque vérification d'angle, sortez le courant via digitalWrite (whitePin), puis vérifiez l'angle et supprimez le courant.

Int vitesseTour = 180 ; //vitesse de rotation, de 0 à 255 //broches pour déterminer la rotation int pinRed = A0; int pinBlanc = A1 ; int pinBlack = A2; int pinAngleStop = 12; // produit du courant vers la LED si l'angle maximum est atteint, // uniquement nécessaire pour le débogage de void setup () ( // broches de rotation pour la lecture pinMode (pinRed, INPUT); pinMode (pinBlack, INPUT); pinMode (pinWhite, INPUT) ); //LED pinMode(pinAngleStop, OUTPUT); //broches du pilote de moteur, direction et vitesse pinMode(angleDirection, OUTPUT); pinMode(angleSpeed, OUTPUT); Serial.begin(9600); ) //fonction appelée depuis la boucle( ), lorsqu'une commande vient d'android void turn(int angle) ( digitalWrite(pinAngleStop, HIGH); //on émet du courant vers le fil connecté au retard positif(5); //on attend un peu pour que le courant ait temps pour atteindre if(angle > 149 ) ( if(digitalRead(pinWhite) == HIGH && digitalRead(pinBlack) == LOW && digitalRead(pinBlack) == LOW) ( //si la position extrême droite est atteinte, quitter la fonction sans appliquer de courant, pour ne pas //brûler le retour du moteur; ) //si l'angle n'est pas maximum, tournez-le digitalWrite(angleDirection, HIGH); analogWrite(angleSpeed, speedTurn); ) else if (angle< 31) { if(digitalRead(pinRed) == HIGH && digitalRead(pinBlack) == HIGH && digitalRead(pinWhite) == HIGH) { //если достигнуто крайне левого положение, выйти из функции не подавая ток, чтобы не //сжечь мотор return; } //если угол не максимальный, поворачиваем digitalWrite(angleDirection, LOW); analogWrite(angleSpeed, speedTurn); } digitalWrite(pinAngleStop, LOW); //убираем ток с определителя угла delay(5); }

Parallélisation des roues roulantes

Initialement, deux moteurs de propulsion sont reliés entre eux. Je les ai déconnectés pour deux raisons : le virage est plus efficace si les roues tournent dans des directions différentes, et une planche ne peut pas supporter deux moteurs puissants.

Problème : le blindage du moteur a deux sorties, chacune délivrant jusqu'à 2 ampères. Chaque moteur consomme 0,7A. Cela semble moins, mais pas aux charges maximales. Disons que la voiture reste coincée dans le sable ou se repose, le courant augmente au-dessus de l'ampère. Pas critique, mais potentiellement dangereux.

Mais le point critique s’est avéré être que la planche chauffe. Une minute et demie après l'enregistrement, le blindage du moteur s'est échauffé et a commencé à fonctionner anormalement : les mauvais courants étaient fournis, les roues ne tournaient pas, etc.

Solution aux deux problèmes : un moteur était connecté à un blindage moteur, le second à l'autre. Curieusement, cela a aidé. La température a baissé et il n'y a pas de surchauffe. Il était possible d'installer un radiateur, mais il était difficile à fixer.

Connexion Bluetooth

J'ai utilisé le modèle HC-05, ce qui était une blague fatale. Tous les appareils Bluetooth sont connectés de la même manière : un fil à 3,3 V (parfois il ne commençait à fonctionner qu'à partir de 5 V), le deuxième au moins, deux autres aux ports 0 et 1 (lecture et envoi, respectivement). Le fil étiqueté RXD pour Bluetooth est branché sur TXD de l'Arduino et TXD sur RXD (si vous le mélangez, vous ne verrez pas les données).

Il y a une mise en garde : les ports 0 et 1 sont utilisés par défaut par Serial, via lequel le croquis est téléchargé. Autrement dit, tant que Bluetooth est branché, le croquis ne sera pas téléchargé. Deux options s'offrent à vous : supprimer le Bluetooth lors du remplissage ou réaffecter les entrées et sorties Bluetooth. La deuxième option s'effectue en deux lignes

#inclure \\connexion de la bibliothèque SoftwareSerial BTSerial(8, 9); \\installer les broches 8 et 9 au lieu de 0 et 1
Le piège qui a rongé mes trois jours de travail était la rapidité de la communication. Par habitude, j'ai installé 9600 et je suis allé essayer. Soit les données ne sont pas arrivées, soit c’était un fouillis de symboles. Et au final la réponse est que le modèle HC-05 communique sur 38400 ! Notez très fortement que dans Setup() je ferai BTSerial.begin(39400) même si Serial.begin(9600).

Système d'envoi de commandes

L'article devient trop long, je vais donc aborder le code Arduino et Android dans une deuxième partie distincte, mais je vais maintenant décrire le principe.

L'appareil Android dispose d'un joystick (un cercle dont la mise en œuvre est également abordée dans la deuxième partie). L'Android en lit les lectures et les convertit en nombres adaptés à Arduino : la vitesse des pixels se transforme en une valeur de -255 à 255 (négatif - inverse), et détermine également l'angle. J'ai délibérément confié cette tâche au téléphone, car il est beaucoup plus puissant et peut facilement compter plusieurs centaines de valeurs par seconde.

Une fois le socket installé, les données sont envoyées au format suivant : @speed#*angle#. @ - indique que les chiffres suivants contiennent la vitesse, # - indique la fin de la valeur de la vitesse, * - le début de la valeur de l'angle, # - termine l'enregistrement de l'angle. Le cycle est sans fin, les commandes sont envoyées toutes les 100 millisecondes (le nombre optimal a été sélectionné). Si rien n’est pressé sur Android, alors rien n’est envoyé.

L'algorithme de réception des données est décrit en détail dans le code d'esquisse. Il a été réécrit plus d'une fois et, quant à moi, il fonctionne parfaitement.

Conclusion de la première partie

Dans cet article j'ai essayé de révéler tout ce qui concerne la partie physique de la machine. Très probablement, j'ai raté quelque chose, alors assurez-vous de demander.

Mais la chose la plus intéressante, quant à moi, a été laissée pour la seconde - le programme Arduino et l'application Android, où la vraie magie se produit, du moins pour mon jeune.

Si vous ne trouvez pas de réponse à une partie et que vous souhaitez me dénoncer personnellement mes lacunes, j'attends - [email protégé], .

UPD : la deuxième partie est déjà sortie -

Après avoir acheté une tablette chinoise 7" bon marché et expérimenté l'interaction avec Arduino via USB et Bluetooth, j'ai voulu faire quelque chose de plus sérieux et utile pour mes enfants. Ainsi est née l'idée de réaliser une machine contrôlée par l'accéléromètre d'un appareil Android. et la communication via Bluetooth. Avant cela, je n'étais jamais intéressé par la robotique ou le contrôle radiocommandé, mais j'en avais envie. Trois objectifs ont été fixés :

1. Créez un appareil aussi simple que possible en termes de répétabilité, que tout radioamateur novice, informaticien, programmeur ou femme au foyer peut répéter. Ceux. un minimum de soudure, et (que les radioamateurs me pardonnent), et l'accent principal devrait être mis sur des modules prêts à l'emploi, bon marché et surtout accessibles qui peuvent être achetés sans aucun problème. Bien sûr, rien ne vous empêche de souder votre propre carte de débogage ou pilote de moteur.
2. Le projet doit être entièrement Open Source et multiplateforme. En tant que partie matérielle, utilisez toutes les plates-formes matérielles et logicielles populaires et modernes : Arduino (traitement), STM32, MSP430, PIC, AVR et peut-être même .
3. Développez entièrement vous-même l'algorithme de contrôle à partir de zéro, sans lire de livres abscons sur la robotique, et rendez-le aussi simple que possible. Eh bien, à l'avenir, il sera possible d'améliorer vos compétences en lisant de la littérature spécialisée et en faisant une gestion plus avancée.

Le véhicule (ou la plate-forme chenillée) est contrôlé en inclinant l'appareil Android. Ceux. incliné vers l'avant - la voiture avance, incliné vers la gauche - la voiture tourne à gauche, vers l'arrière - la voiture recule. De plus, la vitesse de déplacement ou de rotation dépend du degré d'inclinaison de l'appareil. La sensibilité et la valeur d'inclinaison sont définies dans les paramètres de l'application Android. Cette méthode de contrôle est obtenue grâce à l'accès du programme à l'accéléromètre intégré (qui est désormais disponible dans tous les smartphones et tablettes Android modernes).

Une méthode de contrôle hybride a également été mise en place : gaz - à l'aide d'un curseur sur l'écran, et rotation du modèle - en tournant l'appareil Android (comme un volant virtuel). Il y a un bouton séparé pour la marche arrière.
Il existe également une méthode conventionnelle de contrôle à partir des boutons sur l'écran, mais elle est moins fonctionnelle et est principalement utilisée pour le débogage et le test des fonctionnalités.
En plus de tout, par souci de sport, j'ai également mis en place le contrôle tactile, c'est-à-dire un cercle s'affiche sur l'écran, et plus vous déplacez le marqueur vers le haut, plus la voiture va vite ; déplacez votre doigt un peu vers la gauche - la voiture tourne.

Les données sont traitées et transmises via un canal Bluetooth au contrôleur de la machine, qui à son tour contrôle les moteurs de la machine via le pilote de moteur.

Composants

Ainsi, la première chose dont vous aurez besoin est n'importe quel appareil Android : smartphone, tablette, montre, etc., de préférence doté d'un capteur d'inclinaison (accéléromètre) et Bluetooth (ou possibilité de connecter un module externe via USB OTG). J'ai utilisé l'Ainol Aurora chinois avec une clé USB Bluetooth externe. Le prix d’un tel appareil est aujourd’hui inférieur à 100 dollars.

2. Châssis pour la voiture

Vous aurez également besoin de n'importe quel châssis avec 2 ou 4 moteurs. Il peut s'agir soit d'un châssis pour des projets de bricolage, soit d'un châssis d'une vieille voiture radiocommandée d'occasion.
J'ai acheté le châssis fini sur eBay. Pour ceux qui ne connaissent pas encore les enchères en ligne eBay, je recommande de lire cet article :. Je vous garantis que vous économiserez beaucoup d'argent en achetant là-bas, et non ici auprès de revendeurs. Vous pouvez également utiliser d'autres magasins chinois : www.aliexpress.com, dx.com, etc. Trouver un châssis est assez simple, il suffit de saisir l'une des phrases dans la barre de recherche : Châssis de robot, Plateforme de robot, Châssis de voiture DIY, etc. Le coût varie de 20$ à 60$.

Lors du choix d'un châssis, faites attention à l'alimentation et à la puissance des moteurs, ainsi qu'à la vitesse des moteurs et à la présence d'une boîte de vitesses. Bien que la plupart des plates-formes contiennent un moteur standard de 6 V avec boîte de vitesses.

Pour le principe de contrôle décrit dans ce projet, une plate-forme chenillée est la plus adaptée, mais puisque... Je ne l'ai pas encore, j'ai mis en œuvre un projet basé sur une plateforme 4WD.

3. Contrôleur de machines

Comme je l'ai déjà dit, le projet est prévu pour être multiplateforme. Actuellement, le projet CxemCAR a été implémenté pour les plates-formes matérielles suivantes :

1. STM32
2. Arduino
3. Micro-framework .NET

Les « cerveaux » du robot n'exigent pas la vitesse du microcontrôleur et le nombre de périphériques ; le minimum requis que le microcontrôleur doit prendre en charge est : 2 PWM et UART.

Si vous n'avez jamais eu affaire à des microcontrôleurs, alors je vous conseille d'assembler d'abord ce projet sur des cartes Arduino, car... premièrement, ils sont assez bon marché (10-15$), et deuxièmement, Internet et ce site regorgent d'exemples, de manuels, etc. Les contrôleurs STM32 et MSP430 sont plus fonctionnels, mais seront plus difficiles à apprendre pour un débutant. Eh bien, pour les programmeurs, vous aimerez l'une des options de ce projet sur le .NET Micro Framework, où Microsoft Visual C# Express est utilisé comme environnement de programmation. Mais vous devez garder à l'esprit que les cartes FEZ elles-mêmes ne sont pas très courantes et que leur achat est problématique, bien qu'il existe une option .NET pour le facteur de forme Arduino appelée Netduino.

4.Module Bluetooth

Un module UART chinois bon marché HC-06 a été utilisé comme module Bluetooth. Les modules appropriés sont HC-03, HC-04, HC-05, HC-06 et même n'importe quel Bluetooth série. Il est préférable de le prendre avec des broches toutes faites pour ne pas avoir à souder, car... la distance entre les picots est très faible (voir 1er sur la photo ci-dessous). Le coût d'un tel module sur eBay est en moyenne de 5 à 10 $.

Les modules Bluetooth et leur utilisation en relation avec Arduino sont bien décrits dans. Pour les autres contrôleurs, tout est quasiment pareil, avec une description de la communication Bluetooth entre le STM32 et Android.

5. Pilote de moteur

En tant que pilote, j'ai utilisé une puce L298N spécialisée, qui est un pilote de moteur à double pont et est conçue pour contrôler les moteurs à courant continu et pas à pas. Sur eBay, ils vendent des cartes prêtes à l'emploi avec tout le câblage nécessaire, le prix de la carte est de 4 à 5 $ et cela ressemble à ceci :

La connexion à Arduino est décrite de manière suffisamment détaillée dans. Dans notre projet, pour modifier en douceur la vitesse de rotation des moteurs, nous utiliserons le PWM (modulation de largeur d'impulsion).

6. Autres composants

En plus des composants ci-dessus, vous aurez besoin de :
- compartiment à piles (4-5 piles AA) ou piles, vous pouvez utiliser, par exemple, des packs de piles Li-Po 7,4 V prêts à l'emploi
- fils de connexion
- interrupteur
- gaine thermorétractable, colliers de serrage, etc.

Tout cela est bien entendu facultatif et peut être remplacé par ce que vous avez sous la main, par exemple, au lieu de thermorétractable, utilisez du ruban isolant, etc.

Comme vous pouvez le constater, le coût de la machine n'est pas si élevé, si vous utilisez votre propre châssis avec moteurs, cela vous coûtera environ 20 à 25 dollars pour tout ; si vous achetez le châssis, il vous en coûtera entre 45 et 60 dollars, selon le type de châssis (car la fourchette de prix est très large).

Voici ce que j'ai obtenu :

Principe d'opération

Dans l'appareil Android, les commandes de déplacement de la machine sont générées en fonction de l'inclinaison du smartphone/tablette ou du bouton enfoncé. Tous les calculs sont effectués dans l'application Android et les valeurs PWM des moteurs gauche et droit sont immédiatement calculées. L'application dispose de paramètres flexibles, tels que la plage PWM, la sensibilité à l'inclinaison, le seuil PWM minimum, etc. Des commandes telles que :
L-255\rR-120\r
L - commande pour le moteur gauche, R - pour celui de droite
le signe moins signifie faire tourner le moteur pour reculer
255 est le numéro PWM, pour Arduino c'est la vitesse de rotation maximale
\r - fin de la commande.
Avec cette commande, la machine reculera et tournera légèrement vers la droite, car le moteur droit tournera plus lentement que celui de gauche.

L255\rR-255\r
Avec cette commande, le moteur gauche tournera vers l'avant et le moteur droit tournera vers l'arrière, ce qui fera tourner la machine autour de son axe dans le sens inverse des aiguilles d'une montre.

H1\r
Une commande pour allumer un canal supplémentaire, auquel, par exemple, vous pouvez connecter des phares, un signal sonore, etc. A titre d'exemple, un seul canal supplémentaire est affiché, mais le logiciel peut facilement être modifié pour activer davantage de canaux supplémentaires.

Les symboles de commande L, R et H peuvent être définis dans les paramètres de l'application Android.

Le programme du contrôleur fournit une minuterie qui éteint les moteurs si la dernière commande a été reçue il y a plus de n secondes. Le réglage du nombre de secondes est stocké dans la mémoire EEPROM du contrôleur et peut être modifié depuis l'appareil Android. La plage de ce paramètre va de 0,1 s à 99,9 s. De plus, le paramètre peut être complètement désactivé. Mais ensuite, si la connexion est perdue, la machine fonctionnera jusqu'à ce que l'alimentation soit coupée.
Des commandes sont fournies pour travailler avec la mémoire du microcontrôleur Fr- lire les valeurs et Fw- enregistrement des valeurs.

Remplissage électronique

Le schéma fonctionnel de CxemCAR est présenté ci-dessous :

Comme vous pouvez le constater, un module Bluetooth et un pilote de moteur sont connectés au contrôleur (Arduino, STM32, etc.), qui connecte à son tour 2 ou 4 moteurs d'un modèle contrôlé par Bluetooth. Le schéma montre une sortie d'un canal supplémentaire (allumage d'un signal sonore, de phares, etc.), mais en éditant légèrement le programme, le nombre de canaux supplémentaires peut être facilement augmenté.

Travailler avec l'application Android

L'application Android a été écrite dans l'environnement Eclipse. Vous pouvez télécharger toutes les sources du projet et le projet pour Eclipse ci-dessous. Je ne suis pas un expert en programmation Java et c'est ma première application pour Android, donc à certains endroits le code n'est pas entièrement réussi. C'est le développement de l'application Android qui a pris la majeure partie du temps lors du développement de ce projet. La version Android doit être au minimum 3.0, j'ai tout écrit et testé pour une tablette avec la version 4.0.3.

L'application contient plusieurs activités. L'activité principale est l'écran initial avec des boutons permettant de lancer différents modes de contrôle et paramètres :

Il existe 3 modes de contrôle pour le modèle Bluetooth :

Contrôle de l'accéléromètre- la principale méthode de contrôle. Le mouvement du modèle Bluetooth se contrôle en inclinant l'appareil Android (tablette, téléphone, etc.)
Volant virtuel- commande hybride. Gaz - à l'aide du curseur, tourne - en tournant l'appareil. Inverser est un bouton distinct à l’écran.
Contrôle des boutons- l'écran de l'application affiche 4 boutons de commande : avant, arrière, gauche et droite. Lorsque vous appuyez sur le bouton « avant », la voiture avance tant que vous maintenez le bouton enfoncé, lorsque vous appuyez sur « en arrière », la même chose se produit, mais elle recule. Lorsque vous appuyez sur les boutons gauche ou droit, la machine tourne autour de son axe dans un sens ou dans l'autre. Dans ce cas, la valeur de la vitesse est fixe (la valeur par défaut est la vitesse maximale), mais vous pouvez modifier ce paramètre dans les paramètres.
Contrôle tactile- J'ai repéré cette méthode de contrôle dans le jeu DeathRally et, par souci de sport, j'ai décidé de la répéter. Pour être honnête, ce n'était pas très pratique à apprendre, mais cela sera peut-être utile à quelqu'un. Un cercle est dessiné sur l'écran, à l'intérieur duquel se déroule le processus de contrôle. Déplacez votre doigt vers le haut par rapport au centre - la voiture avance, un peu vers la gauche - la voiture commence à tourner à gauche. Concernant cette méthode de contrôle, il existe une autre idée d'amélioration à l'aide d'une boussole, c'est-à-dire n'utilisez pas le cercle comme contrôleur de vitesse et de virage, mais utilisez-le pour définir la direction du mouvement.

Paramètres de l'application

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

Il y a une petite explication pour chaque paramètre ci-dessous, donc je pense qu'il ne devrait y avoir aucune question sur leur objectif. Cependant, je voudrais m'attarder sur certains d'entre eux plus en détail.

Point de pivotement pour moteur (axe X)

Lorsque l'appareil Android est incliné vers la gauche ou la droite, le programme ralentit le moteur vers lequel l'appareil est incliné, c'est-à-dire le tournage est effectué. Cependant, lorsque la valeur d'inclinaison atteint le point de retournement spécifié dans les paramètres, le moteur commence à tourner dans l'autre sens. Si vous inclinez l'appareil sur le côté autant que possible, un moteur tournera à vitesse maximale dans un sens et l'autre dans l'autre, et par conséquent la machine tournera autour de son axe en place.

Adresse Mac

Pour établir une connexion avec le module Bluetooth de la machine, vous devez définir l'adresse MAC dans les paramètres de l'application. Vous devez d'abord configurer le couplage des appareils dans les paramètres de votre appareil Android. Pour cela, allez dans Paramètres -> Bluetooth et cliquez sur « Rechercher des appareils », le téléphone trouve notre module Bluetooh, cliquez dessus et entrez le mot de passe (généralement 1234).

Vous pouvez connaître l'adresse Bluetooth du module à partir de certaines applications, par exemple le terminal Bluetooth. Pour ce faire, cliquez sur « Connecter un appareil - Sécurisé » en bas et dans la fenêtre qui apparaît, cliquez sur le bouton « Rechercher des appareils ». Le logiciel analyse les appareils Bluetooth et affiche leurs adresses MAC :

Cette adresse MAC doit être renseignée dans les paramètres de l'application CxemCAR.

Je ne décrirai pas le logiciel Android lui-même, car... c'est assez fastidieux et donc si vous avez des questions à ce sujet, veuillez contacter le fil de support de ce projet sur le forum.

Assemblage de la plateforme

Comme je l'ai dit plus haut, j'ai choisi le châssis Pirate-4WD du fabricant DFRobot (SKU:ROB0003) comme plateforme. C'est l'un des châssis les plus populaires, voici sa description et vidéo de montage. Bien que tout soit intuitif et que le montage soit très simple.

Une fois la base du châssis avec les moteurs assemblée, nous soudons les fils et marquons les moteurs au cas où :

La photo du haut montre clairement que les moteurs gauche et droit ne sont pas alignés l'un par rapport à l'autre en raison de la mauvaise conception de la conception chinoise, et de ce fait, les roues ont un peu glissé lors du déplacement. Par conséquent, une petite modification a été nécessaire, pour cela j'ai découpé des entretoises en plastique et les ai insérées entre les moteurs.

La situation s'est un peu améliorée, mais il y avait encore un léger mouvement au niveau des roues. Cependant, comme l'ont montré d'autres tests, cela n'a pas beaucoup affecté les performances de conduite de la plate-forme. Par conséquent, je ne suis pas allé plus loin dans la modification du châssis et je l'ai laissé tel quel avec les jambes de force.

L'étape suivante consiste à installer les roues. Ils s'ajustent très étroitement à l'arbre et ont même dû être coupés à certains endroits avec un cutter.

Nous connectons les fils de 4 moteurs à la carte pilote du moteur L298N, les 2 moteurs de gauche sont simplement mis en parallèle, il en va de même pour ceux de droite.

Afin de pouvoir voir l'état de la connexion Bluetooth, le module HC-06 (et d'autres aussi) a la possibilité de connecter une LED d'état. J'ai décidé de le connecter également et de l'afficher dans un endroit bien en vue. Pour ce faire, j'ai utilisé une résistance de limitation de courant de 470 ohms et une gaine thermorétractable.

Nous connectons ou soudons tous les fils nécessaires au module Bluetooth, en plus de la LED, ce sont l'alimentation, GND, TX et RX. Consultez la documentation de votre module Bluetooth. Afin de ne pas souffrir de soudure, je vous conseille de prendre immédiatement un module avec des broches soudées (voir photo ci-dessus). Et il vaut mieux prendre les modules HC-03/HC-05.

J'ai utilisé le module HC-06, que j'avais auparavant. Le schéma de câblage est le suivant :

Une fois soudé, le module ressemble à ceci :

Je l'ai également placé dans une gaine thermorétractable de grand diamètre.

Pour alimenter les moteurs, j'ai utilisé un compartiment à piles avec 5 piles AA, soit La tension d'alimentation du moteur était de 7,5 Volts. Des batteries LiPo et autres peuvent être utilisées. Pour fixer le compartiment de la batterie, j'ai percé deux trous dans le couvercle du châssis et je l'ai fixé avec deux boulons.

Historique des modifications logicielles pour Android :
Version 1.1 (datée du 28 janvier 2013) - modifications dans la classe cBluetooth pour une connexion Bluetooth plus stable. Désormais, vous n'avez plus besoin de saisir de code pour le couplage (liaison d'appareils)
Version 1.2 (du 15/02/2013) - la classe cBluetooth a été ajoutée pour établir une connexion avec l'appareil (utile pour le débogage). Modifications dans la classe Handler (toutes les erreurs statiques ont été corrigées). Un nouveau type de contrôle a été implémenté : le « volant virtuel ».
Version 1.3 (du 20/07/2013) - modifications mineures de l'activité. Correction d'un bug avec l'inversion de coordonnées sur les smartphones

Dans cet article, nous examinerons la connexion et le contrôle d'Arduino via Bluetooth.

Le HC-06, largement utilisé, sera utilisé comme module Bluetooth.

Dans notre projet, nous allumerons et éteindrons la LED connectée au port 13 via Bluetooth.

Commençons par écrire une application pour un smartphone Android. L'application sera écrite dans un environnement de programmation pratique et simple, App Inventor. Les programmes seront compilés en ligne.

Suivez le lien http://ai2.appinventor.mit.edu/. Là, il vous sera demandé de vous connecter à un compte Google, que vous devrez créer si vous n’en avez pas déjà un.

Après vous être connecté, vous serez redirigé vers le programme où vous pourrez créer un projet en cliquant sur « démarrer un nouveau projet ». Vous devrez saisir un nom de projet. Appelons-le led_control.

Une fenêtre d'application vide s'ouvrira.

Ici, nous placerons les composants nécessaires. Sélectionnez ListPicker dans la fenêtre de gauche et déposez-le dans le projet.

Pour le composant ListPicker dans la fenêtre de droite, recherchez la propriété Text et remplacez « Texte pour ListPicker1 » par « Sélectionnez un périphérique BT ».

Ouvrez l'onglet Disposition dans la fenêtre de gauche, placez le composant HorizontalArrangement dans l'application, changez sa propriété width en « Fill parent ». Ajoutez 2 boutons au HorizontalArrangement, définissez la propriété width de chacun d'eux sur « Fill parent ». Ça devrait ressembler à ça:

Changeons les étiquettes des boutons : le premier dira LED ON, le second dira LED OFF.

Ci-dessous, nous ajouterons une étiquette et effacerons son texte.

Reste à ajouter un composant qui organise le transfert de données via Bluetooth. Ouvrez l'onglet Connectivité et placez BluetoothClient dans le projet. Ce composant n'apparaîtra pas sur l'écran du téléphone, mais en dessous, car ce n'est pas visuel.

Vous pouvez maintenant commencer à écrire le programme. Dans la partie supérieure droite du programme, sélectionnez le mode Blocs.

Ici, un programme sera compilé à partir de blocs graphiques. Sur la gauche, cliquez sur le composant ListPicker1 et sélectionnez ListPicker1.BeforePicking.

Cliquez à nouveau sur ListPicker1 et sélectionnez définir ListPicker1.Elements sur

Placez-le comme sur la capture d'écran.

Cela nous donne une liste des appareils Bluetooth couplés. Connectons-nous maintenant à l'appareil sélectionné. Écrivez le bloc comme dans la capture d'écran ci-dessous.

Le bloc rose intitulé Connecté est le premier bloc de l'onglet Texte. Entrez Connecté dans la case vide.

Écrivons maintenant un gestionnaire de boutons. Lorsque vous cliquez sur le premier bouton, le texte « led_on » sera envoyé, et lorsque vous cliquez sur le second, « led_off » sera envoyé. L'inscription dans Label1 changera également.

Il ne reste plus qu'à télécharger le projet sur votre smartphone. Cliquez sur Créer et sélectionnez une méthode de téléchargement.

Pour la première option, vous aurez besoin d’Internet et d’un lecteur de code QR. Cliquez et attendez que le projet soit assemblé et que le code QR soit généré, puis ouvrez le lecteur de code QR sur votre smartphone et lisez le code. Il ne reste plus qu'à télécharger et installer le fichier.

Dans la deuxième option, le projet au format .apk sera enregistré sur votre ordinateur et vous pourrez le télécharger sur votre smartphone de n'importe quelle manière pratique (par exemple via USB).

Commençons maintenant par le programme Arduino.

La réception et la transmission des données s'effectuent via le port COM, nous utiliserons donc Serial. Nous recevrons les signaux caractère par caractère, formerons une chaîne puis comparerons la chaîne générée avec les commandes led_on et led_off.

Arduino

Chaîne val = "" ; void setup() ( Serial.begin(9600); pinMode(13, OUTPUT); ) void loop() ( while (Serial.available()) ( //pendant que les données arrivent char c = Serial.read(); // lisez-les val += c; //et formez une chaîne delay(3); ) if (val != "") ( Serial.println(val); ) if (val == "led_on") ( digitalWrite(13, HIGH ); ) sinon if (val == "led_off") ( digitalWrite(13, LOW); ) val = ""; )

Chaîne val = "" ; void setup() ( En série. commencer(9600); pinMode(13, SORTIE); boucle vide() ( while (Série . disponible () ) ( //pendant que les données arrivent char c = Série . lire(); //Lis-les val += c ; //et crée une chaîne retard(3); }

Téléchargez le code sur Arduino.

Vous pouvez maintenant connecter le module Bluetooth HC-06. Il se connecte très simplement :

Vcc 5v (3,3v possible)

SI VOUS ESSAYEZ DE CHARGER LE PROGRAMME DANS ARDUINO AVEC LE MODULE CONNECTÉ, ALORS UNE ERREUR SORTIRA, CAR LE MODULE ET LE CHARGEMENT DU PROGRAMME UTILISENT LES PORTS RX ET TX !

Mettez l’Arduino sous tension. La LED du module Bluetooth doit clignoter, cela signifie qu'il est en attente de connexion. Prenez votre smartphone, recherchez le Bluetooth dans les paramètres, allumez-le et lancez la recherche. Recherchez l'appareil nommé hc-06 et connectez-vous-y. Cela ne marchera peut-être pas du premier coup. Après un appairage réussi, vous pouvez lancer le programme sur votre smartphone.

Tout d'abord, cliquez sur « Sélectionner un appareil BT » et sélectionnez le module parmi les appareils couplés. Ensuite, appuyez sur les boutons d'allumage et d'extinction de la LED. Si tout est fait correctement, tout fonctionnera.

Nous avons réalisé une application très simple utilisant Bluetooth, sans conception ni même vérification si nous sommes connectés au module ou non. Dans les leçons suivantes, nous créerons des applications plus complexes et nous familiariserons davantage avec App Inventor.

Il existe également des sources pour Android et d'autres informations utiles. Dans cet article, je vais montrer l'assemblage de CxemCAR pour la plateforme Arduino. Presque toutes les cartes compatibles Arduino peuvent être utilisées comme carte Arduino : UNO, Nano, Mega, Leonardo et même Arduino DUE basé sur STM32. J'ai utilisé une carte Arduino Nano V3 achetée sur eBay pour 9 $.

Schéma de connexion pour Arduino au module Bluetooth HC-06 et au pilote de moteur L298N :

Dans le circuit j'ai utilisé un cavalier (dans le circuit Jmp1), car Avec le module Bluetooth connecté, il était impossible de télécharger le croquis sur l'Arduino. Lors de l'installation du micrologiciel, le retrait du cavalier met le module Bluetooth hors tension.

Comme plateforme, j'ai utilisé une petite plateforme RC DIY que j'ai achetée pour 25 $. La plate-forme elle-même est une base en aluminium sur laquelle sont montés deux moteurs, une boîte de vitesses et 4 transmissions à cardan pour 4 roues. D'en haut, sur 3 racks, une planche à pain est placée.

La plateforme n'est pas de grande qualité. Après l'avoir assemblé, j'ai essayé de connecter l'alimentation - les moteurs ne bougeaient même pas, il y avait beaucoup de distorsions, de défauts, etc. J'ai dû tout démonter, desserrer un peu les fixations, affûter ici et là, bien lubrifier le tout, et aussi retirer 2 arbres à cardan du train avant. Le résultat fut une version à propulsion arrière de la voiture.

Après cela, j'ai soudé le module Bluetooth à l'Arduino et lui ai fourni une LED d'état. À propos des types de modules Bluetooth, de leur connexion à Arduino, de leur utilisation, etc. vous pouvez lire dans cet article : . Le module HC-06 a été placé dans une gaine thermorétractable de 10 mm. La LED d'état Bluetooth avec une résistance de limitation de courant a également été placée dans un film thermorétractable, mais plus fin - 5 mm.

J'ai percé des trous dans la planche à pain fournie avec la plate-forme et fixé le pilote du moteur L298N. J'ai fixé la carte Arduino à l'aide de ruban adhésif double face.

Entre la plateforme en aluminium de la machine et la breadboard, j'ai placé 3 batteries Li-Po 3.7V 1100 mAh. Le contrôleur et les moteurs sont alimentés séparément : Arduino est alimenté par une batterie de 3,7 V, et les moteurs et le pilote L298N sont alimentés par deux batteries de 3,7 V connectées en série. Il y a deux interrupteurs d'alimentation à 2 positions : dans une position, l'alimentation passe des batteries aux consommateurs, dans l'autre position, vers les bornes de charge.

Photo de la voiture en charge :

Logiciel

Le programme a été écrit dans Arduino IDE 1.01. J'ai essayé de bien commenter le code du programme, mais si vous avez des questions, posez-les sur le forum, en .

#include "EEPROM.h" #define D1 2 // sens de rotation du moteur 1 #define M1 3 // broche PWM pour contrôler le moteur 1 (à gauche) #define D2 4 // sens de rotation du moteur 2 #define M2 5 // sens de rotation moteur 2 (droite) #define HORN 13 // add. le canal 1 est connecté à la broche 13 //#define autoOFF 2500 // nombre de millisecondes après lequel le robot s'arrête en cas de perte de communication #define cmdL "L" // commande UART pour le moteur gauche #define cmdR "R" // UART commande pour le moteur de droite #define cmdH "H" // Commande UART pour plus. canal 1 (par exemple, signal Horn) #define cmdF "F" // Commande UART pour travailler avec la mémoire EEPROM du MK pour stocker les paramètres #define cmdr "r" // Commande UART pour travailler avec la mémoire EEPROM du MK pour stocker les paramètres (lecture) # définir cmdw "w" // Commande UART pour travailler avec la mémoire EEPROM du MK pour stocker les paramètres (écrire) char incomingByte ; // données entrantes char L_Data; // tableau de chaînes pour les données du moteur gauche L octet L_index = 0 ; // index du tableau char R_Data; // tableau de chaînes pour les données du moteur droit R octet R_index = 0 ; // index du tableau char H_Data; // tableau de chaînes pour plus octet de canal H_index = 0 ; // index du tableau H char F_Data; // tableau de données de chaîne pour travailler avec l'octet EEPROM F_index = 0 ; // Commande de char d'index de tableau F ; // commande : transfert des coordonnées R, L ou fin de ligne non signée longue currentTime, lastTimeCommand, autoOFF ; void setup() ( Serial.begin(9600); // initialise le port pinMode(HORN, OUTPUT); // canal supplémentaire pinMode(D1, OUTPUT); // sortie pour définir le sens de rotation du moteur pinMode(D2 , OUTPUT); / / sortie pour régler le sens de rotation du moteur /*EEPROM.write(0.255); EEPROM.write(1.255); EEPROM.write(2.255); EEPROM.write(3.255);*/ timer_init( ); // initialise le temporisateur logiciel) void timer_init() ( uint8_t sw_autoOFF = EEPROM.read(0); // lit dans l'EEPROM le paramètre "la fonction d'arrêt de la machine est-elle activée en cas de perte de communication" if(sw_autoOFF == "1 ")( // si le minuteur d'arrêt est activé char var_Data ; var_Data = EEPROM.read(1); var_Data = EEPROM.read(2); var_Data = EEPROM.read(3); autoOFF = atoi(var_Data)*100; // variable d'arrêt automatique pour stocker le nombre de ms ) else if(sw_autoOFF == "0")( autoOFF = 999999; ) else if(sw_autoOFF == 255)( autoOFF = 2500; // si rien n'est écrit dans l'EEPROM , alors la valeur par défaut est 2,5 secondes ) currentTime = millis(); / / lit le temps écoulé depuis le lancement du programme) void loop() ( if (Serial.available() > 0) ( // si les données UART sont arrivées incomingByte = Série.read(); // lit l'octet if(incomingByte == cmdL) ( // si des données sont arrivées pour le moteur L command = cmdL; // commande actuelle memset(L_Data,0,sizeof(L_Data)); // efface le tableau L_index = 0; // réinitialiser l'index du tableau) else if(incomingByte == cmdR) ( // si les données du moteur R sont arrivées command = cmdR; memset(R_Data,0,sizeof(R_Data)); R_index = 0; ) else if( incomingByte == cmdH) ( // si données supplémentaires. commande canal 1 = cmdH ; memset(H_Data,0,sizeof(H_Data)); H_index = 0 ; ) else if(incomingByte == cmdF) ( // si les données sont arrivées pour fonctionner avec la mémoire command = cmdF; memset(F_Data,0,sizeof(F_Data)); F_index = 0; ) else if(incomingByte == "\r " ) commande = "e"; // fin de ligne sinon if(incomingByte == "\t") command = "t"; // fin de ligne pour les commandes mémoire if(command == cmdL && incomingByte != cmdL)( L_Data = incomingByte; // enregistre chaque octet reçu dans le tableau L_index++; // augmente l'index actuel du tableau) else if(command == cmdR && incomingByte != cmdR)( R_Data = incomingByte; R_index++; ) else if(command == cmdH && incomingByte != cmdH)( H_Data = incomingByte; H_index++; ) else if(command == cmdF && incomingByte != cmdF)( F_Data = incomingByte; F_index++; ) else if(command == "e")( // si la fin de la ligne est acceptée Control4WD(atoi(L_Data),atoi(R_Data),atoi(H_Data)); delay(10) ; ) else if( command == "t")( // si on accepte la fin de la ligne pour travailler avec la mémoire Flash_Op(F_Data,F_Data,F_Data,F_Data,F_Data); ) lastTimeCommand = millis(); // lit l'heure actuelle qui s'est écoulée depuis le lancement du programme) if(millis() >= (lastTimeCommand + autoOFF))( // compare la minuterie actuelle avec la variable lastTimeCommand + autoOFF Control4WD(0,0,0); // arrête la machine) ) void Control4WD(int mLeft, int mRight, uint8_t Horn)( bool directionL, directionR; // sens de rotation pour L298N byte valueL, valueR; // valeur PWM M1, M2 (0-255) if (mLeft > 0)( valeurL = mLeft; directionL = 0; ) sinon si (mLeft< 0){ valueL = 255 - abs(mLeft); directionL = 1; } else { directionL = 0; valueL = 0; } if(mRight >0)( valeurR = mDroite; directionR = 0; ) sinon si(mDroite< 0){ valueR = 255 - abs(mRight); directionR = 1; } else { directionR = 0; valueR = 0; } analogWrite(M1, valueL); // задаем скорость вращения для L analogWrite(M2, valueR); // задаем скорость вращения для R digitalWrite(D1, directionL); // задаем направление вращения для L digitalWrite(D2, directionR); // задаем направление вращения для R digitalWrite(HORN, Horn); // дополнительный канал } void Flash_Op(char FCMD, uint8_t z1, uint8_t z2, uint8_t z3, uint8_t z4){ if(FCMD == cmdr){ // если команда чтения EEPROM данных Serial.print("FData:"); // посылаем данные с EEPROM Serial.write(EEPROM.read(0)); // считываем значение ячейки памяти с 0 адресом и выводим в UART Serial.write(EEPROM.read(1)); Serial.write(EEPROM.read(2)); Serial.write(EEPROM.read(3)); Serial.print("\r\n"); // маркер конца передачи EEPROM данных } else if(FCMD == cmdw){ // если команда записи EEPROM данных EEPROM.write(0,z1); // запись z1 в ячейку памяти с адресом 0 EEPROM.write(1,z2); EEPROM.write(2,z3); EEPROM.write(3,z4); timer_init(); // переинициализируем таймер Serial.print("FWOK\r\n"); // посылаем сообщение, что данные успешно записаны } }

Le code utilise une bibliothèque pour travailler avec la mémoire EEPROM AVR. Un paramètre est stocké en mémoire : le nombre de millisecondes après lequel la machine s'arrête en cas de perte de connexion. Vous pouvez « coder en dur » ce paramètre dans le programme ; pour cela, décommentez la ligne #define autoOFF 2500 (où 2500 est le nombre de millisecondes). Après cela, la fonction Flash_Op peut être supprimée et il sera également nécessaire d'apporter des modifications mineures au code chargé de recevoir les commandes permettant de travailler avec la mémoire EEPROM.