Vous êtes sur la page 1sur 14

Communication arduino/android et

commande des moteurs


Tout dabord, quest ce quun Arduino ? Arduino est un projet open source cr par des passionns
en Italie en 2005 pour des tudiants. Cest une plateforme lectronique basique laquelle on a
affect un microcontrleur, ici lATMEGA 328. Loriginalit de ce projet tient dans le fait que
lArduino seul ne peut faire quun nombre limit de choses mais en lui ajoutant des modules les
possibilits offertes deviennent infinis. Il est programmable par ordinateur via un programme en
JAVA ce qui garantie sa portabilit. La connexion avec lordinateur se fait via USB et le protocole
RS232 est utilis. Le module basique est en plus de tout cela peu cher, son nom est larduino Uno Rev
3, appel par abus de langage dans ce dossier Arduino .
Ce dossier prsente comment lArduino peut permettre de rpondre aux besoins explicits dans le
cahier des charges par le biais de rponse des problmatiques dpendantes les unes des autres.

Problmatique : Comment permettre physiquement la carte Arduino de se


connecter en Bluetooth au Smartphone ?

Le Bluetooth :
La carte Arduino seule na pas dantenne, il est donc impossible dtablir avec une connexion sans fil
Bluetooth, il faut donc utiliser un module Bluetooth :
Module Bluetooth :

Permet dtablir la communication entre


lArduino et le Smartphone grce au protocole
Bluetooth et son antenne intgre.
On peut ainsi relier larduino et le Smartphone
grce au protocole Bluetooth.

Problmatique : Comment permettre physiquement a la carte Arduino de


commander les moteurs en respectant le cahier des charges ?

Commande des moteurs :


La carte arduino peut commander des moteurs, elle peut mme moduler cette vitesse grce
lutilisation de signal PWM.
Signal PWM : Le signal PWM est un signal permettant de moduler une tension moyenne que lon
envoie le plus souvent un moteur, une tension et une priode T sont tablie, par exemple 5V
pendant 10ms, cette tension est envoy sur la borne pendant une dure t, par exemple 4ms, ainsi, la
borne est aliment en 5V pendant 4ms toutes les 10ms, la tension moyenne devient donc une
tension de 2V. On obtient un
taux de modulation valant t/T,
ici 40%.
En modifiant ce temps t on
modifie la tension
dalimentation trs simplement.

Si lArduino peut thoriquement commander les moteurs de cette faon, cela nest pas suffisant pour
garantir son efficacit, un effet, en tudiant la documentation de larduino on apprend que lintensit
sur chaque borne peut aller jusqu' 50mA (cf : http://arduino.cc/en/Main/ArduinoBoardUno)
Or notre source de courant qui alimentera les moteur devra fournir une intensit pouvant aller
jusqu' 800mA, il est donc impossible dutiliser directement larduino pour commander le moteur, il
faut donc passer par un module dalimentation.
Module dalimentation des moteurs :
Ce module permet une alimentation en toute
scurit des moteurs, il utilise une
alimentation externe pour rcuprer le
courant et le signal PWM de larduino pour
alimenter jusqu' deux moteurs en courant
continu. On notera aussi quil utilise 4 autres
bornes de larduino pour permettre de
paramtrer le sens de rotation de chaque
moteur dans le sens horaire ou antihoraire.
Il permet ainsi de respecter toutes les
caractristiques du cahier des charges.

Problmatique : Comment relier les deux modules lArduino ?

Caractristique des connexions entre lArduino et ses modules :


La connexion entre les diffrents modules et lArduino se fait par un empilement des modules sur
lArduino ainsi, on peut connecter sur lArduino le module Bluetooth et au dessus du module
Bluetooth le module dalimentation des moteurs.

Chaque module Bluetooth utilise des bornes spcifiques dfinis dans la documentation technique de
chacun deux :

Cette connaissance du cblage est ncessaire pour la rsolution des problmatiques suivantes.

Problmatique : Comment programmer lArduino de faon pouvoir discuter


avec le Smartphone et commander les moteurs ?

Etablissement de la connexion Bluetooth entre larduino et le Smartphone :


Pour se connecter en Bluetooth au Smartphone, lutilisation dune librairie t ncessaire, en effet
ce module et vendu avec une librairie qui est ncessaire au bon fonctionnement de ce dernier, elle
contient notamment une fonction qui permet de sauthentifier et de se connecter un autre
priphrique Bluetooth, cette fonction appele au tout dbut du programme se divise en trois
phases :
- le paramtrage du module
- la mise en attente de connexion
- le vidage du buffer
Quand la fonction est termin, mme si le module nest toujours pas connect, il va se mettre en
attente et attendra quun Smartphone se connecte, voil le code C de ce paramtrage :

Paramtrage du
module

Mise en attente de
connexion.
Vidage du buffer

blueToothSerial.begin(38400); // La vitesse de transmission est dfinie 38400 bauds


blueToothSerial.print("\r\n+STWMOD=0\r\n"); // paramtrage du module en tant
quesclave.
blueToothSerial.print("\r\n+STNA=MotoDuino\r\n"); // paramtrage du nom du module en
tant que MotoDuino
blueToothSerial.print("\r\n+STOAUT=1\r\n"); // Permet a des priphriques dj connects
de se connecter au module.
blueToothSerial.print("\r\n+STAUTO=0\r\n"); // Interdit la connexion automatique
delay(2000); // This delay is required.
blueToothSerial.print("\r\n+INQ=1\r\n"); // rend le priphrique connectable
Serial.println("The slave bluetooth is inquirable!");
delay(2000); // This delay is required.
blueToothSerial.flush(); // Vidage du buffer, important pour ne pas lire des caractres
rsiduels de la connexion ou dune dernire communication.

Il a fallu aussi tablir un protocole denvoi des donnes du Smartphone vers lArduino.

Problmatique : Sous quelle forme envoyer les donnes ncessaires lArduino


pour commander les moteurs ?

Etablissement du protocole de communication entre le Smartphone et


lArduino :
Pour connaitre lorientation du tlphone, on dispose de trois informations, la position angulaire en
Z, X et Y. Chacune de ces positions est dfinie par un nombre dcimal compris dans un usage normal
entre -10 et 10 et ayant jusqu 5 dcimales. On a dfinit que le Smartphone devait envoyer ces
informations sous la forme :

X:1,23456
Axe sur lequel t
prlev linformation.

Nombre dcimal
entre -10 et 10.

Dlimiteur.

Remarques :
- On filtre le : qui ne sert pas sinon pour le debuguage.
- La valeur envoy peut dpasser 10 ( ou tre infrieur -10), cela serait du des mouvement
brusques.
- La taille maximal dune valeur est donc de 10 caractres (lettre + signe - + 2 chiffres (nombre
suprieur 10) + , + 5 dcimales ).
On notera que pour obtenir les trois valeurs dans une mme entit il faudrait recevoir 40 caractres,
en effet, il faut rcuprer lquivalent de 4 valeurs pour tre certain den avoir trois compltes (cf
lexemple de trame), soit 40 caractres.
Ex de trame potentiellement recevable :

,3456X:-9,33257Y:2,73658Z:10,23456X:1,27
Ici X vaudrait -9,33257, Y vaudrait 2,73658 et Z vaudrait 10,23456.
La position angulaire de laxe X,Y et Z sont ainsi envoys en continu et peuvent ainsi permettre a
lArduino de connaitre linclinaison du tlphone sur chacun de ces axes.
On se rappellera des informations donnes par Maxime sur limpact de lorientation Smartphone sur
les valeurs envoys, nanmoins voici un petit rappel rapide ncessaire pour la comprhension de la
partie suivante :
X>0

X<0

Y=10

Y<10

Z>0

Z<0

Problmatique : Comment traiter les informations reus de faon pouvoir


commander les moteurs ?

Cration du programme dinterprtation des donns reus et de contrle


des moteurs :

Macro principale

Paramtrage du module
Bluetooth et mise en
attente de connexion.

Variables Globales
Algorigramme du
programme potentiel pour
assurer la communication
Arduino/Androd et la
commande des moteurs.

Cration dun
tableau de 40 cases

Tant que 1 vaut 1

Tant que module


Bluetooth non appair

Cration des
variables de type
entier : X,Y et Z
Extraction des valeurs en
X, Y et Z du tableau

Tant que le tableau


na pas t lu entirement.

Tant que le
tableau nest pas rempli
Rception dun
caractre Bluetooth et
placement dans le
tableau

Lecture de la
valeur dune case
du tableau
Si la valeur
est X

Oui

Non
Si la valeur
est Y

Extraction des
valeurs en X, Y et
Z du tableau

Utilisation des valeurs


prcdentes pour
moduler la vitesse du
moteur

Transformation en
valeur numrique
des 9 cases suivantes
et placement dans la
variable X.

Oui

Transformation en
valeur numrique
des 9 cases suivantes
et placement dans la
variable Y.

Non
Si la valeur
est Z
Non

Oui

Transformation en
valeur numrique
des 9 cases suivantes
et placement dans la
variable Z.

Paramtrage du module Bluetooth


et mise en attente de connexion.

Pour plus
dinformations
retourner la page n4

Paramtrage du
module Bluetooth

Mise en attente de
connexion

Vidage du buffer.

Modulation de la vitesse
des moteurs

Paramtrage du
module pour faire
tourner le moteur
dans le sens horaire.

Oui

Si Z plus grand
que 0
Non

Paramtrage du
module tel que le
vhicule tourne
gauche.

Oui

Si X plus grand
que 0

Paramtrage du module
pour faire tourner le
moteur dans le sens antihoraire.

Non
Dfinition de la vitesse
de rotation des
moteur en fonction de
Y.

Paramtrage du
module tel que le
vhicule tourne
droite.

Lalgorithme dcoulant de cette algorigramme doit permettre de faire fonctionner lArduino en


respectant le cahier des charges.

Toutes les problmatiques ont t rsolues et lalgorigramme t cr, il suffit


maintenant de crer le programme et de passer aux phases de tests.

Cration du programme :
Pour programmer larduino il faut utiliser un Environnement de Dveloppement Intgr
communment appel IDE (en anglais), comme son nom lindique cest un logicielle qui permet de
dvelopper pour une plateforme dans un ou plusieurs langages (compilation pour la plateforme
donn). Il intgre un grand nombre doutil permettant de faciliter la cration des programmes, en
voici une deux intgrs dans celui de larduino :
- Un dbogueur, utile pour savoir o linterprtation du code chouera.
- Un mulateur de moniteur srie, il permet de voir les messages que nous envoie larduino,
extrmement utile lors du dveloppement des programmes, du dbogage ou encore des phases
dexprimentations.
Le langage utilis par lIDE est un langage extrmement proche du C, cest pour cela que lon dit par
extension que lArduino est programm en C.

La phase dexprimentation est divise en trois parties :


- la premire vrifie le bon fonctionnement de la partie Bluetooth et du traitement des donnes
- la seconde vrifie que lArduino commande bien les moteurs sans quils soient connects
- la dernire vrifie le bon fonctionnement de lArduino une fois mont sur le vhicule. ( faire)

Vrification du bon fonctionnement de la partie Bluetooth et du traitement


des donnes :
Pour vrifier que cette partie fonctionner il faut dabord vrifier que les caractres envoys par le
Smartphone sont bien reus, on utilise donc le moniteur Srie pour voir le contenu tableau :

Chaque ligne reprsente le tableau remplie


entirement, on voit qua chaque lignes
sont prsentes au moins une fois les valeurs
compltes de X, Y et Z. On peut donc
extraire en toute scurit les valeurs.

Il faut ensuite vrifier que lextraction des valeurs prsentes dans le tableau se fait bien de la faon
que lon souhaite, on utilise de nouveau le moniteur srie et on affiche les valeurs extraites de
chaque tableau :

On voit que le contenu du tableau est


chaque fois bien extrait. De plus, quand
une valeur est suprieure 10
(soulign), elle est rabaisse 9.99, cela
permet de faciliter les calculs pour
calculer la tension mettre dans les
moteurs.
On rcupre ainsi toutes les valeurs
ncessaires la dfinition de la tension
mettre dans les moteurs.

Vrification du bon fonctionnement de lArduino dans la commande des


moteurs :
Lalgorithme cr doit permettre de faire fonctionner la voiture en marche avant, marche arrire et
de la faire tourner en avanant, le moniteur srie a tout dabord t utiliser pour vrifier ces
caractristiques :
Marche avant :

Marche arrire :

On voit que quand Z est positive le shield moteur est programm en marche avant et quand Z est
ngatif le shield moteur est programm en marche arrire.
Tournant vers la gauche :

On voit ici que le moteur gauche serait moins


aliment que le moteur droit ce qui permettrait
au vhicule de tourner vers la gauche.

Tournant vers la droite :

On voit ici que le moteur droit serait moins


aliment que le moteur gauche ce qui permettrait
au vhicule de tourner vers la droite.

Modulation de la vitesse via linclinaison du tlphone sur laxe Y :


Vhicule larrt :

Vhicule en avance rapide :

On voit que quand Y est proche de 10 (tlphone la vertical) les moteurs ne sont que trs peu
aliments et qua linverse quand le tlphone est lhorizontal (Y proche de 0) les moteurs sont
quasiment aliments au maximum.
Ainsi lArduino devrait normalement pouvoir rpondre toutes les exigences dfinis dans le cahier
des charges dans la communication arduino/androde en vue dune commande de vhicule motoris.
Le vhicule ntant pas encore achev il est pour linstant impossible de tester larduino en
conditions rels, le principe a tout de mme t vrifi avec un systme de LED.

10

Maquette du montage effectu avec ISIS :

Les Entrs M1 et M2
simulent les mmes
entrs prsentent sur le
module dalimentation
des moteurs, cest ces
sorties que seront relis
les moteurs. Cela permet
de vrifier dans quel sens
tournerait le moteur et
lintensit lumineuse
nous informe sur la
tension libr.

11

12

Annexe : Programme
Arduino :
#include <SoftwareSerial.h>
//Software Serial Port
#define RxD 6 // sont bien
configurs mme si c'est
bizarre...
#define TxD 7
#define DEBUG_ENABLED 1
#define EA 9
#define EB 10
#define IN1 8
#define IN2 11
#define IN3 12
#define IN4 13
#define droite 1
#define gauche 2
SoftwareSerial
blueToothSerial(RxD,TxD);
void setup()
{
Serial.begin(9600);
pinMode(RxD, INPUT);
pinMode(TxD, OUTPUT);
pinMode(13,OUTPUT);
pinMode(12,OUTPUT);
pinMode(11,OUTPUT);
pinMode(10,OUTPUT);
pinMode( 9,OUTPUT);
pinMode( 8,OUTPUT);
setupBlueToothConnection();
}
int restatVal(int val);
void loop()
{
char recvChar;
char tabVal[40];//(X12.99999)10 max * 4
int x;
static float valX=0;
static float valY=0;
static float valZ=0;
static int memZ=0;
static int moteurA=0;
static int moteurB=0;
static int directionM = 0;
while(1){

if(blueToothSerial.available()){/
/check if there's an , data sent
from the remote bluetooth
shield
x=0;
while(x<40)
{

48)*0.001;

tabVal[x]=blueToothSerial.read
();
if((tabVal[x]>='0'&&tabVal[x]<
='9')||(tabVal[x]>='X'&&tabVal
[x]<='Z')||tabVal[x]==','||tabV
al[x]=='-')x++;
}
int i,ii;
int rang;
for(ii=0;ii!=40;ii++)
{
Serial.print(tabVal[ii]);
}
Serial.println("");
int boolX,boolY,boolZ;
boolX=0;
boolY=0;
boolZ=0;
for(i=0;i!=40;i++)
{

if(tabVal[i]=='Y'&&!boolY)
{
boolY=1;
rang=i+1;
int signe=0;
float valeur=0;
if(tabVal[rang]=='-')
{
signe=1;
rang++;
}

if(tabVal[i]=='X'&&!boolX)
{
boolX=1;
rang=i+1;
int signe=0;
float valeur=0;
if(tabVal[rang]=='-')
{
signe=1;
rang++;
}

if(tabVal[rang+2]==',')valeur=9.
99;
if(signe)valeur*=1;
valX=valeur;
}

valeur=(float)(tabVal[rang]-48);
valeur+=(float)(tabVal[rang+2]48)*0.1;
valeur+=(float)(tabVal[rang+3]48)*0.01;
valeur+=(float)(tabVal[rang+4]48)*0.001;
if(tabVal[rang+2]==',')valeur=9.
99;
if(signe)valeur*=-1;
valY=valeur;
}

valeur+=(float)(tabVal[rang+3]48)*0.01;

if(tabVal[i]=='Z'&&!boolZ)
{
boolZ=1;
rang=i+1;
int signe=0;
float valeur=0;
if(tabVal[rang]=='-')
{
signe=1;
rang++;
}

valeur+=(float)(tabVal[rang+4]-

valeur=(float)(tabVal[rang]-48);

valeur=(float)(tabVal[rang]-48);
valeur+=(float)(tabVal[rang+2]48)*0.1;

13

valeur+=(float)(tabVal[rang+2]48)*0.1;
valeur+=(float)(tabVal[rang+3]48)*0.01;

moteurA=(int)((10.0valX)*(10.0valY)*255.0/100.0);
moteurB=(int)((10.0valY)*255.0/10.0);
moteurA=restatVal(moteurA);

valeur+=(float)(tabVal[rang+4]48)*0.001;
if(tabVal[rang+2]==',')valeur=9.
99;
if(signe)valeur*=-1;
valZ=valeur;
}
}
Serial.print("X:");
Serial.print(valX);
Serial.print(" Y:");
Serial.print(valY);
Serial.print(" Z:");
Serial.print(valZ);
Serial.println("");

moteurB=restatVal(moteurB);
analogWrite(EA,moteurA);
analogWrite(EB,moteurB);
Serial.println("gauche");
}
if(directionM==droite)
{
moteurA=(int)((10.0valY)*255.0/10.0);
moteurB=(int)((10.0valX)*(10.0valY)*255.0/100.0);
moteurA=restatVal(moteurA);

if(valX<0)
{
directionM=droite;
valX*=-1.0;
}
else
directionM=gauche;
if(valZ>=0&&memZ<1)
{
memZ=1;
digitalWrite(IN1,HIGH);
digitalWrite(IN2,LOW);
digitalWrite(IN3,HIGH);
digitalWrite(IN4,LOW);
}
if(valZ<=0&&memZ>-1)
{
memZ=-1;
digitalWrite(IN1,LOW);
digitalWrite(IN2,HIGH);
digitalWrite(IN3,LOW);
digitalWrite(IN4,HIGH);
}
if(directionM==gauche)
{

moteurB=restatVal(moteurB);
analogWrite(EA,moteurA);
analogWrite(EB,moteurB);
Serial.println("droite");
}
if(memZ==1)Serial.println("Ma
rche avant");
if(memZ==1)Serial.println("Marche
arrire");
Serial.print("A:");
Serial.print(moteurA);
Serial.print("B:");
Serial.print(moteurB);
Serial.println("");Serial.println(
"");
}
if(Serial.available()){//check
if there's any data sent from
the local serial terminal, you

can add the other applications


here
recvChar = Serial.read();
blueToothSerial.print(recvChar
);
}
}
}
int restatVal(int val)
{
if(val>255)val=255;
if(val<30)val=0;
return val;
}
void
setupBlueToothConnection()
{
blueToothSerial.begin(38400);
//Set BluetoothBee BaudRate
to default baud rate 38400
blueToothSerial.print("\r\n+ST
WMOD=0\r\n"); //set the
bluetooth work in slave mode
blueToothSerial.print("\r\n+ST
NA=MotoDuino\r\n"); //set
the bluetooth name as
"SeeedBTSlave"
blueToothSerial.print("\r\n+ST
OAUT=1\r\n"); // Permit
Paired device to connect me
blueToothSerial.print("\r\n+ST
AUTO=0\r\n"); // Autoconnection should be
forbidden here
delay(2000); // This delay is
required.
blueToothSerial.print("\r\n+IN
Q=1\r\n"); //make the slave
bluetooth inquirable
Serial.println("The slave
bluetooth is inquirable!");
delay(2000); // This delay is
required.
blueToothSerial.flush();
}
14