Rapport final Mr JILBAB

Introduction

L'AR.Drone de la société Parrot, est le premier quadricoptère piloté par un iPhone/iPod-

Touch/iPad ainsi que par la plupart des appareils mobiles Wi-Fi basé sur Android. L'AR.Drone

n'est pas implement

un quadricoptère télécommandé, c'est aussi le cœur d'une plate-forme de jeu à réalité

augmentée multijoueur.Il est conçu pour une utilisation en extérieur et en intérieur grâce à une

carène prévue pour le Protéger des chocs et pour éviter le contact avec les hélices en rotation.

En plus du pilotage intuitif de l'AR.Drone par de simples mouvements appliqués au

mobile, les caméras embarquées nous permettent d'avoir une vision en direct de l'aéronef sur

l'écran du mobile à quelques dizaines de mètres grâce au réseau Wi-Fi établi entre l'AR.Drone

et son mobile de pilotage.

Bien qu’il s’agisse d’un drone du commerce, celui-ci peut se transformer en une

plateforme pour la programmation. Alors notre objectives c’est de d’avoir un autopilotage de

l’AR drone de telle façon à suivre une ligne blanche sur un trajet.

La démarche qu’on va suivre est :

-Une acquisition de la donnée : dans notre cas c’est une vidéo à temps réelle.

-Un prétraitement de la donnée : c’est la mise en forme du signale.

-Un traitement avec extraction de l’information : échantillonnage de la vidéo et extraction du

contour.

-Le contrôle de l’AR drone : la commande de la partie motorisation de l’AR drone.

Fig. 1: l'AR.Drone Fig. 2: L'AR.Drone avec

carène

-Pui une simulation pour tester la démarche.

Présentation du système AR Drone

1.2 Décomposition de l'AR.Drone :

Afin de comprendre la structure interne de l'AR.Drone, il est utile de proposer, dans un

premier temps, une décomposition du bloc « AR.Drone » sous la forme d'un diagramme de

définition de blocs (voir BDD page suivante), puis dans un deuxième temps, d'étudier les flux

entre les différentes parties.

Les principaux blocs sont :

• « CarteMere » : C'est l'unité de traitement (le nom « Carte Mère » choisi pour ce bloc

vient de l'appellation donnée par la société Parrot aux pièces détachées remplaçables

par l'utilisateur comme les moteurs, les hélices, etc.). C'est sur cette unité de traitement

que s'exécute le système d'exploitation Linux et le micro-logiciel responsable du fonc-

tionnement global de l'AR.Drone (voir Annexe A). On rappelle les principales caracté-

ristiques de la carte mère dans

le tableau suivant :

Processeur • Processeur P6 conçu pour Parrot basé sur l'ARM9 468 MHz

Mémoire • Mémoire flash NAND 32Mo

• RAM DDR 128 Mo à 200MHz

Système d'exploitation • Linux

• « CarteMoteur » : cette carte embarque une unité de traitement spécifique et l'électro-

nique nécessaire pour contrôler la vitesse d'un moteur. On y adjoint le réducteur et

l'hélice pour compléter la description. Comme l'indique la multiplicité, l'AR.Drone

possède 4 cartes moteur.

• « CarteNavigation » : cette carte est aussi composée d'une unité de traitement et des

composants électroniques et MEMS (Microelectromechanical systems) nécessaires

pour relever l'altitude, les vitesses angulaires et les accélérations linéaires de

l'AR.Drone (blocs « Altimetre » et « CentraleInertielle »). Le but de cette carte est de

fournir les données permettant à la carte mère de calculer l'altitude, les angles de rou-

lis, tangage et lacet (roll, pitch et yaw) et les vitesses linéaires pour les axes X, Y et Z

de l'AR.Drone.

• « CameraFrontale » et « CameraVerticale » : caméras embarquées sur l'AR.Drone

permettant au joueur de visualiser en temps réel l'avant et le sol vue de l'AR.Drone.

Les images de la caméra verticale sont aussi utilisées pour la stabilisation de

l'AR.Drone. On rappelle les principales caractéristiques des caméras :

Caméra Frontale • Diagonale de la lentille 93°

• Capteur CMOS.

• Résolution 640x480 pixels (VGA)

• 15 images/sec.

Caméra Verticale • Diagonale de la lentille 64°

• Capteur CMOS.

• Résolution 176x144 pixels (QCIF)

• 60 images/sec.

• « ReseauWifi » : permet la communication sans fil de l'AR.Drone avec la Station-Sol.

Le réseau Wi-Fi mis en place par l'AR.Drone est de type Ad-Hoc et respecte le stan-

dard IEEE 802.11g. Les principales caractéristiques de ce réseau sont résumées dans

le tableau ci-dessous :

Composant Wi-Fi AR.Drone • Chipset Atheros AR6102 (voir Annexe D)

Standard • IEEE 802.11g

Vitesse des données • 1~54 Mbits/s

Bande de fréquences • 2.4 GHz

Distances de fonctionnement • En théorie :

◦ jusqu'à 40m en intérieur

◦ jusqu'à 140m en extérieur

• En pratique : la portée de l’AR.Drone dépend de

l’environnement dans lequel il évolue : elle sera

d’autant plus grande que l’AR.Drone évoluera dans un

espace plus ouvert et plus pauvre en ondes Wi-Fi. À

titre d’indication, la portée moyenne est de 50 mètres.

• « BatterieLiPo » : batterie embarquée sur l'AR.Drone fournissant l'énergie nécessaire

pour faire fonctionner les moteurs, l'intelligence de contrôle et les communications

avec la Station-Sol. Les principales caractéristiques de la batterie sont rappelées dans

le tableau suivant :

Type • Lithium polymère

Nombre de cellules • 3 cellules de 3.7V

Tension • 11.1V

Capacité • 1000mAh

Temps de charge • 90 minutes

Capacité de décharge • 10C = 10 A (peut fournir instantanément

10 fois sa capacité soit 10 x 1000mAh)

Schéma globale de la décomposition:

1.2 Diagramme de bloc interne de l'AR.Drone

Fig. 3: IBD AR.Drone

On donne les principales caractéristiques des liaisons entre les instances de blocs :

• Liaison « CarteMere » - « CarteMoteur »: elle est constituée de deux ports :

un port standard pour la sélection du moteur. Exemple : m1:Gpio

un flux ttyPA1:UART : c'est une liaison série de type RS232 servant de support

aux données échangées entre la carte mère et le moteur (commandes et états du

moteur, commande led, etc.) selon un protocole propriétaire (non documenté).

• Liaison « CarteMere » - « CarteNavigation » : elle est constituée de 3 ports :

un port standard pour la sélection de la carte de navigation : /cs:Bit

un flux ttyPA2:UART : c'est aussi une liaison série de type RS232 servant de

support aux données échangées entre la carte mère et la carte de navigation

(données brutes des accéléromètres, gyroscope, et altimètre) selon un protocole

propriétaire (non documenté).

un flux ICSP:Gpio : (re)programmation du micro-logiciel de la carte de

navigation

• Liaison « CarteMere » - « CameraFrontale » et « CarteMere » - « CameraVerticale

» : flux à différentes composantes (contrôle de la caméra et données vidéo).

• Liaison « CarteMere » - «ReseauWifi » : bus de données et de contrôle entre l'unité

de traitement et le composant chargé de la communication sur le réseau Wi-Fi.

Un deuxième diagramme de bloc interne orienté « Énergie » montre les différentes liaisons

pour l'alimentation en énergie des blocs.

Fig. 4: IBD AR.Drone - Énergie

Diagramme de bloc interne de la carte moteur de l'AR.Drone

Le diagramme de la page suivante montre une décomposition de haut niveau de la carte

moteur. On y retrouve les blocs suivants :

• « UniteControlMoteur » : unité de traitement chargée d'appliquer les consignes mo-

teurs issues de la carte mère.

• « PontInverseur » : système de commutation d'énergie vers les enroulements du mo-

teur.

• « CircuitDetectionPosRotor » : système de détection de la position du rotor (contrôle

du sens/vitesse de rotation).

• « Moteur » : le tableau suivant donne les principales caractéristiques du moteur :

Rated voltage 12V DC

No phase 3 phases

Operating voltage 5.0 - 12.0V DC

Rated load Propeller

Rated speed 42000+-7%rpm

Temperature range Working temp : 0°C - 30°C

No load speed 52000+-7%rpm

No load current 600mA Max

Insulation resistance 10M Ohm Min

Terminal resistance 600+-50mOhm

• « Reducteur » et « Helice » : propulsion

• « Led » : led de statut de l'AR.Drone (prêt à voler, urgence, animations, etc.)

Traitement de donnée :

On constate qu’on peut accéder au flux de donnée et avoir les données des deux camé-

ras, et aussi les communiqués avec un périphérique externe (ordinateur ou smartphone …) à

travers la carte réseau de l’AR alors on peut faire un traitement sur ordinateur ou smartphone

et déduire un résultat sur ces derniers.

Dans ce cas, notre traitement sera la détection d’une ligne blanche sur un trajet de

l’AR Drone, ce travail sera fait à l’aide du logiciel MATLAB.

La Détection du contour :

Le but de la détection de contours est de repérer les points d'une image numérique qui

correspondent à un changement brutal de l'intensité lumineuse. Ces changements de propriétés

de l'image traduisent en général des événements importants ou des changements dans les pro-

priétés du monde. Ils incluent des discontinuités dans la profondeur, dans l'orientation d'une

surface, dans les propriétés d'un matériau et dans l'éclairage d'une scène.

La détection des contours d'une image réduit de manière significative la quantité de

données et élimine les informations qu'on peut juger moins pertinentes, tout en préservant les

propriétés structurelles importantes de l'image.

La détection des contours d'une image réduit de manière significative la quantité de

données et élimine les informations qu'on peut juger moins pertinentes, tout en préservant les

propriétés structurelles importantes de l'image. Il existe un grand nombre de méthodes de

détection de l'image mais la plupart d'entre elles peuvent être regroupées en deux catégories.

La première recherche les extremums de la dérivée première, en général les maximums locaux

de l'intensité du gradient. La seconde recherche les annulations de la dérivée seconde, en général

les annulations du laplacien ou d'une expression différentielle non-linéaire.

Dans notre cas il faut détecter ou extraire le contour d’une ligne blanche

Programmation à l’aide de MATLAB

Les étapes de traitement :

Apporter les données : c’est la vidéo.

Echantillonnée en séquence les images de la vidéo.

Seuillage de l’image (Binarisation).

Filtrage de l’image.

Détection de la ligne blanche.

Détection du changement de trajet de la ligne.

Assemblage des images résultantes.

Fig 6: exemple de trajet qu’on peut avoir d’une ligne blanche

http://fr.wikipedia.org/wiki/Gradient

http://fr.wikipedia.org/wiki/Laplacien

Programme principal:

clear all

close all

obj=mmreader('vidNacer4.avi'); %Charger la vidéo

a=read(obj); %Lecture de la vidéo

frames=get(obj,'numberOfFrames'); %Récuperer le nombre de frames dans la vidéo

for k = 1 : frames

img1 = a(:,:,:,k);

img1=rgb2gray(img1);

img1= im2bw(img1,0.8);

img=img1;

%Boucle de seuillage des différentes frames de la vidéo

img= bwareaopen(img,1000); %Supression des regions qui contient moins de 1000 pixels

blancs

se = strel('disk',1); %Création d’une matrice de filtrage

img = imerode(img,se); % Image filtré

figure(1);

subplot(121);imshow(img);hold on %Affichage de l’image

centre = barycentre(img); % barycentre c’est une fonction qui cherche le centre de l’image

[i,j]=find(img==1); % Cherche les pixels = 1

j1=find(img(max(i),:)==1); % Cherche les pixels blancs situant en bas

j2=find(img(min(i),:)==1); % Cherche tous les pixels blancs situant en haut

%Le calcule la moyenne des pixels situant en bas et en haut de l’image

plot(round(mean(j1)),max(i),'r*');hold on

plot(round(mean(j2)),min(i),'g*');hold on

x=[ round(mean(j1)) centre(2) round(mean(j2)) ];

y=[ max(i) centre(1) min(i) ];

p = polyfit(x,y,1); % On cherche la droite qui rassemble les trois point dans une seul droite

l=[p(1) -1 p(2)]';

% Notre droite est ecrite sous la forme l=[alpha betha gama] alpha*x + betha*y + gama =0

l2=[-1 0 0]';

ang=atand(l(1)*l2(2)-l2(1)*l(2))/(l(1)*l2(1)+l(2)*l2(2))+90; % On calcule l’angle entre la

droite calcule l et la droite l2

x=1:size(img,2);

y=-(l(1)*x+l(3))/l(2);

plot(y,'r');hold off % On affiche la droite rouge calculer précédemment

% On affiche la flèches de l’angle calculer par « ang »

subplot(122);compass(cos(deg2rad(ang))+1i*sin(deg2rad(ang)));

disp(ang); % Afficher l’angle sur la ligne de commande

Programme du Barycentre :

% Cette fonction cherche le centre de l’image binaire

function centre = barycentre(F)

[M N]=size(F);

% On initialise les valeurs suivant

valeurx=0;

valeury=0;

nbpoint=0;

% On fait un balayage de l’image pixel par pixel

for i = 1 : M

for j = 1 : N

if F(i,j)==1 %Si on a un pixel égal à 1 on calcul les nouvelles valeurs des variable

valeurx=valeurx+i;

valeury=valeury+j;

nbpoint=nbpoint+1;

end

end

end

% On calcule le centre de notre image en calculant la formule suivante

centre = [round (valeurx/nbpoint) ; round (valeury/nbpoint) ];

Simulation sur Matlab

Dans cette figure la droite rouge suit bien la trajectoire de la ligne blanche.

Dans cette figure on a un changement de trajectoire de la ligne blanche on voit bien que

la droite rouge essai de suivre le nouveau trajet.

Commande de l’AR Drone

Nous avons estimé le trajet de la ligne blanche, alors on peut communiquer ces données avec

le ficher de commande de l’AR Drone (voire l’annexe).

La partie de commande de trajet de L’AR Drone est la suivante :

%-------------------------------------------------------------------------% % % % définition du traject souhaitable de L'AR Drone % % % %-------------------------------------------------------------------------% % Altitude tAltitude = [data(41) data(42) data(43) data(44)]; drone.Altitude = single(typecast(tAltitude,

'int32'))/ 1000;

% X Velocity Vx = [data(45) data(46) data(47) data(48)]; drone.X_Velocity = typecast(Vx, 'single') / 1000;

% Y Velocity Vy = [data(49) data(50) data(51) data(52)]; drone.Y_Velocity = typecast(Vy, 'single') / 1000;

% Entire NavData Packet drone.NavData = data; end %--------------------------------------------------------------------------

Conclusion :

Ce travail nous a permet de familiariser avec les techniques de traitement d’images qu’on n’a vue

théoriquement lors du cours de traitement d’image. Ainsi l’application de ces techniques dans un

système réel l’AR Drone .nous avons confronté pas mal de problèmes techniques lors de ce travail tel

que l’implémentation pratique du programme sur l’AR Drone à cause des problème lors de la

simulation du programme de la commande de l’AR Drone ainsi un manque de connaissance u niveau

de fichier de paramétrage du système .mais ce travail est un support assez fort et important pour

autre applications de l’AR Drone tel que l’implémentation ou l’exploitation du GPS et le traitement d’image pour un Autopilotage.

Annexe :

classdef ARDrone < handle

% ARDrone Class

% Controls AR Parrot Drone

properties

seq = 3;

ARc;

ARn;

% NavData Properties

Control_State = [];

Battery_Voltage = 0;

Pitch = 0;

Roll = 0;

Yaw = 0;

Altitude = 0;

X_Velocity = 0;

Y_Velocity = 0;

NavData = 0;

end

methods

function [obj] = ARDrone()

instrreset

clc

global fh;

%Create Control connection

obj.ARc = udp('192.168.1.1', 5556, 'LocalPort', 5556);

fopen(obj.ARc);

fh = 0;

%Create NavData connection

obj.ARn = udp('192.168.1.1', 5554, 'LocalPort', 5554, ...

'ByteOrder', 'littleEndian', ...

'InputBufferSize', 500, ...

'BytesAvailableFcn', {@navPacketRxCallback,obj}, ...

'DatagramTerminateMode', 'on', ...

'BytesAvailableFcnMode', 'byte', ...

'BytesAvailableFcnCount', 24);

fopen(obj.ARn);

% Byte to NavData port for initialization

fwrite(obj.ARn, 1);

% NavData command to command port

AR_NAV_CONFIG = sprintf('AT*CONFIG=2,\"general:navdata_demo\",\"TRUE\"\r');

fprintf(obj.ARc, AR_NAV_CONFIG);

% Flicker LEDs

obj.command('LED', '1,5,5,5,5')

function navPacketRxCallback(obj, event, drone)

if (get(obj, 'BytesAvailable') ~= 0)

data = fread(obj);

data = uint8(data);

if ~isempty(data);

% Drone Control State Information

drone_state = [data(5) data(6) data(7) data(8)];

drone_state = typecast(drone_state, 'uint32');

for i = 1:32

drone.Control_State(i) = bitget(drone_state, i);

end

% Battery Voltage Percentage

vBattery = [data(25) data(26) data(27) data(28)];

drone.Battery_Voltage = typecast(vBattery, 'uint32');

% Theta (Pitch) Values

tPitch = [data(29) data(30) data(31) data(32)];

drone.Pitch = typecast(tPitch, 'single') / 1000;

% Phi (Roll) Values

tRoll = [data(33) data(34) data(35) data(36)];

drone.Roll = typecast(tRoll, 'single') / 1000;

% Psi (Yaw) Values

tYaw = [data(37) data(38) data(39) data(40)];

drone.Yaw = typecast(tYaw, 'single') / 1000;

%------------------------------------------------------------------------------------------------------------------------------------

-

% Altitude

tAltitude = [data(41) data(42) data(43) data(44)];

drone.Altitude = single(typecast(tAltitude, 'int32'))/ 1000;

% X Velocity

Vx = [data(45) data(46) data(47) data(48)];

drone.X_Velocity = typecast(Vx, 'single') / 1000;

% Y Velocity

Vy = [data(49) data(50) data(51) data(52)];

drone.Y_Velocity = typecast(Vy, 'single') / 1000;

% Entire NavData Packet

drone.NavData = data;

end

%----------------------------------------------------------------------------------------------------------------------------------------

% Reset Drone Watchdog Bit

AR_WDG = strcat('AT*COMWDG=',num2str(drone.seq),',');

fprintf(drone.ARc, AR_WDG);

drone.seq = drone.seq + 1;

% if fh ~= 0

% if strcmp(get(fh, 'Selected'), 'off')

% set(fh, 'Selected', 'on')

% end

% end

%

end

end

end

function command(obj, command_type, code)

AR_CMD = sprintf( 'AT*%s=%i,%s\r', command_type, obj.seq, code);

fprintf(obj.ARc, AR_CMD);

obj.seq = obj.seq + 1;

end

function takeoff(obj)

obj.command('FTRIM','')

obj.command('CONFIG','\"control:altitude_max\", \"20000\"')

obj.command('REF','290718208')

end

function hover(obj)

obj.drive([0,0,0,0])

end

function land(obj)


end

function emergency(obj)



end

function drive(obj, speed)

% Controls the robot movement directly using motor speeds

fvel = typecast(single(speed(1)/2), 'int32');

lvel = typecast(single(speed(2)/2), 'int32');

uvel = typecast(single(speed(3)/2), 'int32');

rvel = typecast(single(speed(4)/2), 'int32');

fvel_str = strcat(num2str(fvel),',');

lvel_str = strcat(num2str(lvel),',');

uvel_str = strcat(num2str(uvel),',');

rvel_str = num2str(rvel);

obj.command('PCMD',strcat('1,', lvel_str, fvel_str, uvel_str, rvel_str))

end

function moveUp(obj, speed)

obj.drive([0,0,speed,0])

end

function moveDown(obj, speed)

obj.drive([0,0,-speed,0])

end

function moveLeft(obj, speed)

% Moves the robot left at a specific speed

obj.drive([0,-speed,0,0])

end

function moveRight(obj, speed)

% Moves the robot right at a specific speed

obj.drive([0,speed,0,0])

end

function moveForward(obj, speed)

% Moves the robot forward at a specific speed

obj.drive([-speed,0,0,0])

end

function moveReverse(obj, speed)

% Moves the robot forward at a specific speed

obj.drive([speed,0,0,0])

end

function rotateLeft(obj, omega)

% Rotates robot left

obj.drive([0,0,0, -omega])

end

function rotateRight(obj, omega)

obj.drive([0,0,0, omega])

end

function stop(obj)

% Stop all Robot motion and close communications.

obj.land

fclose(obj.ARn);

fclose(obj.ARc);

end

function control(obj, varargin)

clc

disp('Controls');

disp('arrow keys = up,down,rotate_left,rotate_right');

disp( 'w,a,s,d = move:forward,backward,left,right');

disp('enter,spacebar,shift = takeoff,land,hover');

disp('q = quit program');

% Manually control robot using W/S (forward/reverse), A/D

% (strafe left/right), I/K (vertical up/down), J/L (turn left/right)

% E (emergency stop), and Q (quit) keys.

global fh;

if nargin == 2

vel = varargin{1};

else

vel = .5;

end

left = 0;

bottom = 0;

width = 100;

height = 150;

fh = figure(...

'name','ARDrone Controller', ...

'keypressfcn',@keyPress, ...

'windowstyle','modal',...

'numbertitle','off', ...

'Position',[left bottom width*3 height],...

'userdata','timeout',...

'Color','white') ;

t = timer('TimerFcn',{@display_Nav,obj},'ExecutionMode','fixedRate');

start(t)

function keyPress(~, event)

%obj.display_Nav();

if (strcmp(event.Character, 'q'))


stop(t)

delete(t)

delete(fh)

fh = 0;

end

cmd = event.Key;

switch (cmd)

case 'return' % Take off

obj.takeoff()

case 'space' % Land

obj.land()

case 'e' % Emergency

obj.emergency()

case 'a' % Rotate Left

obj.rotateLeft(vel)

case 'd' % Rotate Right

obj.rotateRight(vel)

case 'uparrow' % Up

obj.moveUp(vel)

case 'downarrow' % Down

obj.moveDown(vel)

case 'shift' % Hover

obj.hover()

case 'leftarrow' % Left

obj.moveLeft(vel)

case 'rightarrow' % Right

obj.moveRight(vel)

case 'w' % Forward

obj.moveForward(vel)

case 's' % Backward

obj.moveReverse(vel)

case 'q'

disp('Quitting...')

otherwise

disp('Unknown Command')

end

end

function display_Nav(value,event,obj)

left = 0;

bottom = 0;

width = 100;

height = 150;

labels = uicontrol('Style','text','Position',[left bottom width height],'HorizontalAlignment', 'left',

'FontSize', 14,'BackgroundColor','white');

str1 = 'Battery';

str2 = 'Pitch';

str3 = 'Yaw';

str4 = 'Roll';

str5 = 'Altitude';

str6 = 'X_Velocity';

str7 = 'Y_Velocity';

set(labels,'String',{str1,str2,str3,str4,str5,str6,str7});

values = uicontrol('Style','text','Position',[left+width bottom width

height],'HorizontalAlignment', 'right', 'FontSize', 14,'BackgroundColor','white');

str1 = num2str(obj.Battery_Voltage);

str2 = num2str(obj.Pitch);

str3 = num2str(obj.Yaw);

str4 = num2str(obj.Roll);

str5 = num2str(obj.Altitude);

str6 = num2str(obj.X_Velocity);

str7 = num2str(obj.Y_Velocity);

set(values,'String',{str1,str2,str3,str4,str5,str6,str7});

units = uicontrol('Style','text','Position',[left+width+width+10 bottom width height],'HorizontalAlignment', 'left', 'FontSize', 14,'BackgroundColor','white');

str1 = num2str('volts');

str2 = num2str('degrees');



str5 = num2str('meters');

str6 = num2str('meters/sec');

str7 = num2str('meters/sec');

set(units,'String',{str1,str2,str3,str4,str5,str6,str7});

end

end

end

end

Rapport final Mr JILBAB

Documents