Vous êtes sur la page 1sur 5

Gérez le robot Arduino en utilisant le capteur G sur votre

smartphone
Dans cet article, vous apprendrez à utiliser ce service RemoteXY très facile à mettre en
place une plateforme robotisée de télécommande ou une voiture à deux moteurs. Le robot
que nous allons gérer avec l'élément de contrôle "joystick" qui peut fonctionner avec le G-
sensor de votre smartphone. À la fin, vous trouverez la vidéo et pourrez voir ce que nous
avons.
Nous avons assemblé une plate-forme à deux roues très simple qui vous montrerait
comment construire un système de télécommande. La plate-forme comprend les
composants suivants (nous ne revendiquons pas la fabrication ; la plate-forme est
assemblée pour démontrer les capacités de la ressource RemoteXY):

Châssis - nous avons éliminé son matériau en feuille ;


• La roue avant - la roue tourne à 360 degrés ;
• Moteurs à engrenages 2 pièces ;
• Roue, avec l'axe adapté aux motoréducteurs 2 pcs. Roues que nous avons achetées avec
Motoréducteur ;
• Compartiment à piles avec interrupteur sur les 4e piles de type AA ;
• Arduino, nous avons utilisé le même clone Seeeduino ;
• Module Bluetooth HC-06 ;
• Puce de commande de moteur L298N ;
Câblage électrique et toutes les machines modules représentées dans la figure suivante
Programme de gestion
Utilisez l'éditeur de cette ressource et construisez le contrôle d'interface suivant :
Réglez au milieu de l'écran "joystick". Dans les propriétés du joystick pour sélectionner un
contrôle supplémentaire "Activer le capteur G". Sélectionnez la position du commutateur G-
Sensor "en bas à gauche". Les mêmes paramètres peuvent changer la couleur en rouge. À
l'avenir, nous serons un joystick pour contrôler le mouvement de la machine.
Réglez "Switch". Mettez-le à gauche du joystick. Vous pouvez également changer sa
couleur. Switch, nous allons piloter la LED sur la carte Arduino à la broche 13.
Si vous avez tout fait correctement, vous devriez avoir à peu près l'interface de gestion :

Dans les paramètres du projet, sélectionnez la plate-forme cible, pour laquelle nous
obtenons le code source : "Arduino (Software Serial), version de la bibliothèque". Appuyez
sur le bouton "Obtenir le code" et téléchargez le code source sur votre ordinateur. En
téléchargeant la bibliothèque de liens RemoteXY et en l'installant dans l'IDE Arduino.
Ouvrez l'esquisse téléchargée dans l'IDE Arduino. Un croquis parfait se compile sans
erreurs. Cependant, ce n'est certainement pas un code pour gérer notre machine. Notre
tâche est de corriger ce code. Pour correct, nous utiliserons l'exemple téléchargé.
Faites attention à la définition de la structure RemoteXY dans le croquis du projet. La
structure contient des champs qui sont entièrement conformes aux contrôles établis sur
l'interface utilisateur. Nous voyons les variables joystick_1_x et joystick_1_y, reflétant les
coordonnées x et y du joystick, ainsi que la variable switch_1, reflétant le commutateur.
/ * cette structure définit toutes les variables de votre interface de
contrôle * /
struct {
   
    / * variable d'entrée * /
  signé char joystick_1_x; / * = -100..100 Position du joystick en
coordonnées x * /
  signé char joystick_1_y; / * = -100..100 Position du joystick à
coordonnées y * /
  unsigned char switch_1; / * = 1 si allumé et = 0 si éteint * /

    / * autre variable * /


  unsigned char connect_flag; / * = 1 si fil connecté, sinon = 0 * /

} RemoteXY;

Le suivant est le code du programme principal, qui est déjà construit contrôle les moteurs de
notre plate-forme de robot. Vous pouvez simplement copier ce code ci-dessous dans votre
croquis, ou ajouter sélectivement les morceaux de code nécessaires dans l'exemple
téléchargé.

///////////////////////////////////////////////
// Bibliothèque d'inclusion RemoteXY //
///////////////////////////////////////////////

/ * RemoteXY sélectionne le mode de connexion et inclut la bibliothèque * /


#define REMOTEXY_MODE__SOFTWARESERIAL
#include <SoftwareSerial.h>
#include <RemoteXY.h>

/ * Paramètres de connexion RemoteXY * /


#define REMOTEXY_SERIAL_RX 2
#define REMOTEXY_SERIAL_TX 3
#define REMOTEXY_SERIAL_SPEED 9600

/ * Configurer RemoteXY * /
caractère non signé RemoteXY_CONF [] =
  {3,0,23,0,1,5,5,15,41,11
  , 43,43,1,2,0,6,5,27,11,5
  , 79,78,0,79,70,70,0};
    
/ * cette structure définit toutes les variables de votre interface de
contrôle * /
struct {

    / * variable d'entrée * /


  signé char joystick_1_x; / * = -100..100 Position du joystick en
coordonnées x * /
  signé char joystick_1_y; / * = -100..100 Position du joystick à
coordonnées y * /
  unsigned char switch_1; / * = 1 si allumé et = 0 si éteint * /

    / * autre variable * /


  unsigned char connect_flag; / * = 1 si fil connecté, sinon = 0 * /

} RemoteXY;

///////////////////////////////////////////////
// FIN RemoteXY include //
///////////////////////////////////////////////
/ * défini les bonnes broches de contrôle moteur * /
#define PIN_MOTOR_RIGHT_UP 7
#define PIN_MOTOR_RIGHT_DN 6
#define PIN_MOTOR_RIGHT_SPEED 10
/ * défini les broches de contrôle moteur gauche * /
#define PIN_MOTOR_LEFT_UP 5
#define PIN_MOTOR_LEFT_DN 4
#define PIN_MOTOR_LEFT_SPEED 9

/ * défini la broche LED * /


#define PIN_LED 13

/ * défini deux tableaux avec une liste de broches pour chaque moteur * /
char non signé RightMotor [3] =
  {PIN_MOTOR_RIGHT_UP, PIN_MOTOR_RIGHT_DN, PIN_MOTOR_RIGHT_SPEED};
caractère non signé LeftMotor [3] =
  {PIN_MOTOR_LEFT_UP, PIN_MOTOR_LEFT_DN, PIN_MOTOR_LEFT_SPEED};

/ *
   contrôle de la vitesse du moteur
   moteur - pointeur vers un tableau de broches
   v - la vitesse du moteur peut être réglée de -100 à 100
* /
void Wheel (moteur non signé char *, int v)
{
  si (v> 100) v = 100;
  si (v <-100) v = -100;
  si (v> 0) {
    digitalWrite (moteur [0], HIGH);
    digitalWrite (moteur [1], LOW);
    analogWrite (moteur [2], v * 2,55);
  }
  sinon si (v <0) {
    digitalWrite (moteur [0], LOW);
    digitalWrite (moteur [1], HIGH);
    analogWrite (moteur [2], (-v) * 2,55);
  }
  autre {
    digitalWrite (moteur [0], LOW);
    digitalWrite (moteur [1], LOW);
    analogWrite (moteur [2], 0);
  }
}

void setup()
{
  / * broches d'initialisation * /
  pinMode (PIN_MOTOR_RIGHT_UP, OUTPUT);
  pinMode (PIN_MOTOR_RIGHT_DN, OUTPUT);
  pinMode (PIN_MOTOR_LEFT_UP, OUTPUT);
  pinMode (PIN_MOTOR_LEFT_DN, OUTPUT);
  pinMode (PIN_LED, OUTPUT);

  / * module d'initialisation RemoteXY * /


  RemoteXY_Init ();

boucle vide ()
{
  / * module de gestionnaire d'événements RemoteXY * /
  RemoteXY_Handler ();

  / * gérer la broche LED * /


  digitalWrite (PIN_LED, (RemoteXY.switch_1 == 0)? LOW: HIGH);

  / * gérer le bon moteur * /


  Roue (moteur droit, RemoteXY.joystick_1_y - RemoteXY.joystick_1_x);
  / * gérer le moteur gauche * /
  Roue (LeftMotor, RemoteXY.joystick_1_y + RemoteXY.joystick_1_x);
}
Au début de défini une broches qui seront utilisées pour contrôler les moteurs. De plus - les
broches sont regroupées en deux matrices, moteur gauche et moteur droit respectivement.
Pour contrôler chaque moteur via la puce pilote L298N nécessaire d'utiliser trois signaux :
deux discrets, le sens de rotation du moteur, et un analogique, déterminant la vitesse de
rotation. Calcul de ces broches, nous avons engagé dans la fonction Wheel. L'entrée de la
fonction passe un pointeur du moteur sélectionné du réseau de broches et la vitesse de
rotation en tant que valeur signée de -100 à 100. Si la valeur de la vitesse est 0, le moteur
est éteint.
Dans une configuration de fonction prédéterminée configurée sont des broches de sortie.
Pour les broches utilisées pour le signal analogique, qui peuvent fonctionner comme des
convertisseurs PWM. Ces broches 9 et 10, elles n'ont pas besoin d'être configurées dans
l'IDE Arduino.
Dans une boucle de fonction prédéterminée à chaque itération du programme appelant la
bibliothèque RemoteXY du gestionnaire. De plus, il y a le contrôle des LED, puis contrôle les
moteurs. Pour la commande du moteur, lisez les coordonnées X et Y du joystick dans la
structure des champs de RemoteXY. Sur la base des coordonnées est une opération pour
calculer la vitesse de chaque moteur, et la fonction d'appel Wheel, est définie la vitesse du
moteur. Ces calculs sont effectués à chaque cycle du programme, garantissant un contrôle
continu des broches des moteurs en fonction des coordonnées du joystick.
Téléchargez l'esquisse résultante dans le contrôleur Arduino. Téléchargez et exécutez
l'application mobile sur votre smartphone ou tablette. Connectez-vous à votre appareil robot
et vous pouvez le contrôler. Le joystick peut être utilisé en mode normal en déplaçant le
curseur avec votre doigt. Vous pouvez sélectionner G-sensor, et le robot se déplacera en
fonction de la pente de votre smartphone.
Si votre appareil après la construction, un ou les deux moteurs tournent dans le sens
opposé, inversant la connexion lors de la connexion du moteur