Tout d'abord, je veux signaler deux/trois choses sur le drone :
  • Malgré une très bonne stabilité, le drone semble souffrir d'un bug (dans sa version actuelle 1.1.3) qui peut aller jusqu'à provoquer un crash et donc la casse du drone... Ce bug se manifeste quand on vole au dessus de l'herbe: le sonar semble avoir du mal à estimer la hauteur. Il se met en défaut et le drone peut partir tout seul plein gaz à plusieurs dizaines de mètres de haut et les tentatives de redescendre ou d'atterrissage sont vaines. Par deux fois il m'a fait le coups et par deux fois j'ai été obligé de presser le bouton emergency... Il semblerait qu'on soit plusieurs à avoir constaté ce problème. Espérons que Parrot nous fasse une mise à jours rapidement.
  • On peut facilement remplacer la batterie d'origine par une autre LiPo 3S de plus grosse capacité (essayé une 2000mAh sans problèmes). Il y a de la place et le connecteur est un mini tamiya. L'autonomie passe ainsi de 10/12 minutes à 20/25 minutes.


Utilisation du SDK

Bien, Après m'être inscrit (non sans mal) sur le site "developper" de Parrot, j'ai pu avoir accès au SDK (release-1_0_4_ARDrone_Version_20100716_1_0_4_RC).
La première chose qu'on peut dire, c'est que ce SDK est assez fouillis et que la documentation est une denrée rare... Bref, après quelques heures de vadrouille dans le code on fini par comprendre que le SDK en lui même se situe dans le dossier ARDroneLib, qu'il est composé de trois bibliothèques statiques :
  • lib_vlib contient le code qui permet de lire, décoder et encoder le flux vidéo provenant de la camera du drone.
  • lib_sdk contient les fonctions de base, la gestion des threads, des sockets...
  • lib_ardrone contient les fonctions qui vont permettre de se connecter au drone, de le piloter et de le configurer. Cette bibliothèque contient partie nommée "ardrone_tool" qui offre tous les accès de haut niveaux, l'implémentation du protocole de communication et toutes les structures qui vont bien pour récupérer les infos du drone.


Chose surprenante, le SDK contient son propre main() et c'est à l'utilisateur du SDK d'implémenter les callbacks proposés par le SDK.
Par défaut, ce sont trois callbacks à implémenter :
  • C_RESULT ardrone_tool_init_custom(int argc, char **argv); appelé à l'initialisation du programme.
  • C_RESULT ardrone_tool_shutdown_custom(); appelé à intervalle régulier pendant l'exécution du programme.
  • C_RESULT ardrone_tool_tool_update_custom(); appelé lors de l'arret du programme initié soit par l'utilisateur, soit par le sdk.

Suite à cela, il faut s'inscrire à deux autres services pour avoir accès aux informations du drone et pour lui envoyer des commandes.

Le service qui permet d'obtenir toutes les informations provenant du drone comme son statut, ses codes erreurs ou ses informations de navigation s'appelle "navdata".
Pour s'y inscrire il faut ajouter les blocs suivant :
BEGIN_NAVDATA_HANDLER_TABLE
// On déclare ici les callbacks que le SDK appellera pour fournir les informations de navigation
NAVDATA_HANDLER_TABLE_ENTRY(my_navdata_client_init, my_navdata_client_process, my_navdata_client_release, NULL)
END_NAVDATA_HANDLER_TABLE

BEGIN_THREAD_TABLE
THREAD_TABLE_ENTRY( navdata_update, 20 )
END_THREAD_TABLE

Puis de déclarer et d'implémenter les fonctions qui seront appelé lors de l'initialisation, l'update et la destruction des données de navigation :
  • C_RESULT my_navdata_client_init( void* data );
  • C_RESULT my_navdata_client_process( const navdata_unpacked_t* const navdata ); la structure navdata_unpacked_t contient toutes les informations de navigation, les codes erreurs, etc etc etc...
  • C_RESULT my_navdata_client_release( void );


Pour piloter le drone, la marche à suivre est similaire : On inscrit le service dans la table des threads :
BEGIN_THREAD_TABLE
THREAD_TABLE_ENTRY( ardrone_control, 20 )
// ...
END_THREAD_TABLE

Puis on déclare une structure de type input_device_t qui contient les pointeurs vers les fonctions à appeler pour initialiser, updater et releaser le device qui va servir à piloter le drone :
C_RESULT open_myControl(void);
C_RESULT update_myControl(void);
C_RESULT close_myControl(void);

input_device_t myControl = {
  "myControl",
  open_myControl,
  update_myControl,
  close_myControl
};

Puis d'ajouter dans le callback ardrone_tool_init_custom un appel à la fonction qui permet d'enregistrer les callbacks :
ardrone_tool_input_add( &myControl );

Ainsi que dans le callback ardrone_tool_shutdown_custom :
ardrone_tool_input_remove( &myControl );



Exemple complet

Si, comme moi, vous souhaitez utiliser le sdk dans un projet existant et possédant déjà son propre main(), il vous faut alors modifier un peu le sdk.
Voici les étapes à suivre :
  • Éditez le fichier release-1_0_4_ARDrone_Version_20100716_1_0_4_RC/ARDroneLib/Soft/Build/config.makefile
    Et remplacez :
    RELEASE_BUILD=yes
    QUIET_BUILD=yes
    BUILD_LINUX_EXAMPLES=no

  • Éditez le fichier release-1_0_4_ARDrone_Version_20100716_1_0_4_RC/ARDroneLib/Soft/Build/custom.makefile
    Et remplacez :
    USE_ARDRONE_MAINLOOP=no

  • Éditez release-1_0_4_ARDrone_Version_20100716_1_0_4_RC/ARDroneLib/VP_SDK/VP_Api/vp_api_stage.c
    Remplacez chaque occurrence de "USE_LINUX" par "USE_LINUX_SDL"
  • Puis, pour compiler les bibliothèques du SDK, faites :
    cd ardrone/release-1_0_4_ARDrone_Version_20100716_1_0_4_RC/ARDroneLib/Soft/Build
    make


Vous trouverez ICI l'archive contenant un exemple en C n'utilisant pas le main() du SDK.
Pour le compiler, il faut recompiler le SDK comme expliqué ci-dessus, éditer le fichier "build.sh" présent dans l'archive pour lui renseigner le chemin vers votre sdk puis l'exécuter "./build.sh" pour compiler le fichier "test.c".