diff --git a/README-en.md b/README-en.md
deleted file mode 100644
index 541f4bf..0000000
--- a/README-en.md
+++ /dev/null
@@ -1,144 +0,0 @@
-# Installation #
-
-This package was developped with the Indigo version of ROS.
-
-## Dependencies installation ##
-```
-#!sh
-sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu trusty main" > /etc/apt/sources.list.d/ros-latest.list'
-wget https://raw.githubusercontent.com/ros/rosdistro/master/ros.key -O - | sudo apt-key add -
-sudo apt-get update
-sudo apt-get install ros-indigo-desktop-full ros-indigo-freenect-stack ros-indigo-ardrone-autonomy libncursesw5-dev
-```
-## Package installation ##
-
-### Catkin workspace creation ###
-
-For instance :
-
-```
-#!sh
-source /opt/ros/indigo/setup.bash
-mkdir -p ~/hand_control_ws/src
-cd ~/hand_control_ws/src
-catkin_init_workspace
-```
-
-### Code location ###
-
-If necessary, rename the folder with the file named `hand_control`, and move it in `~/hand_control_ws/src/` or in the subfolder `src` of your catkin workspace.
-
-## Compilation ##
-
-You're now able to compile :
-
-```
-#!sh
-cd ~/hand_control_ws # or your catkin workspace
-catkin_make
-```
-
-Then you can run the following commands to be able to use the ROS commands. If necessary replace "hand_control_ws" by the name of your catkin workspace.
-
-```
-#!sh
-source /opt/ros/indigo/setup.bash
-source ~/hand_control_ws/devel/setup.bash
-echo "source /opt/ros/indigo/setup.bash" >> ~/.bashrc
-echo "source ~/hand_control_ws/devel/setup.bash" >> ~/.bashrc
-```
-
-# Use #
-
-## Connection and setting up of the Kinect ##
-
-1. Connect the Kinect (under voltage) to the computer via USB ;
-2. Put the Kinect on the ground, pointed toward the roof ; be aware that your arm must be perpendicular to the Kinect in order to control the drone properly ;
-2. Launch the "launchfile" kinect_commander.launch : `roslaunch hand_control kinect_commander.launch` ;
-3. Check the drone parameters :
-    - launch rviz :  `rosrun rqt_rviz rqt_rviz`
-    - display the output of the filtering (topic : `/filter/output` ; frame : `/camera_depth_optical_frame`) and locate the hand ;
-    - launch rqt_reconfigure : `rosrun rqt_reconfigure rqt_reconfigure` in order to :
-      - change the filter parameters until you only see the points of the hand/glove/panel on rviz (see above).
-      - change the parameter `neutral_alt` of the node `commander` to the wanted height (in meters), correponding to the height of the hand for which the height of the drone will be stable.
-    
-### Parameters of the filter ###
-
-The parameters of the filter (that can be changed thanks to `dynamic_reconfigure` and in particular `rqt_reconfigure`) are :
-
-* `z_max` : in meters, maximal height of the hand. It must be lower than the height of the roof.
-* for a glove or a *colored* panel (green, blue, etc.), we generaly have :
-    - `hue` : for example 220 (sky blue) or 150 (green) or 0 (pink/red) ;
-    - `delta_hue` : between 10 and 20 ;
-    - `sat/val_min` : 0.0 ;
-    - `sat/val_max` : 1.0 ;
-* for a *black* glove :
-    - `hue` : 0 ;
-    - `delta_hue` : 180 ;
-    - `sat_min` : 0.0 ;
-    - `sat_max` : 1.0 ;
-    - `val_min` : 0.0 ;
-    - `val_max` : 0.3 (at your convenience);
-
-### Other parameters ###
-
-Always with `rqt_reconfigure`, but with the `estimator` node :
-- `reverse` : swap x and y, the axes of the Kinect (default : false, ie. unchecked)
-- `reverse_angle` : change the angle choosen for the compute of the angle of the hand (default : false, ie. unchecked)
-
-## Connection to the drone and steering ##
-
-* Connect the computer to the wifi network of the drone ;
-* Launch the "launchfile" ardrone.launch : `roslaunch hand_control ardrone.launch` ;
-* Taking off : 
-    - whether `rostopic pub /ardrone/takeoff std_msgs/Empty` ;
-    - or launch the node keyboard_cmd : `rosrun hand_control keyboard_cmd` and use *t* on the keyboard.
-* Landing :
-    - whether `rostopic pub /ardrone/land std_msgs/Empty` ;
-    - or, launch the node keyboard_cmd, and use *b* on the keyboard.
-* Emergency stop :
-    - whether `rostopic pub /ardrone/reset std_msgs/Empty` ;
-    - or, launch the node keyboard_cmd, and use *g* on the keyboard.
-
-### Hand steering ###
-
-* Forward/backward & side translations : hand tilt ;
-* Rotate (around the vertical axis z) : angle of the hand with the the axis parallel to the ground and perpendicular to the kinect ;
-* go up/go down : hand height.
-
-### Options and parameters of the command ###
-
-To edit the options of the command, change (if not already) `rosrun rqt_reconfigure rqt_reconfigure` :
-
-- `max_curvature` : not used for the moment ;
-- `x/y/z/theta_minimal_deviation` : thresholds required above which the movement of the hand is not taken into account. If all are 0.0, the drone responds linearly.
-    * x, y : between 0. and 1. (corresponding to the x and y of the normal to the plane);
-    * z : in meters ;
-    * theta : in degrees.
-- `neutral_alt` : height of the hand for the immobility of the height of the drone ;
-- `min_points_number` : minimal number of points (for the point cloud used for the regression) necessary in order to send a command to the drone ;
-- `angle/x/y/z_vel` : proportionality coefficients to apply to the inputs in order to establish the command sent to the drone. Increase it will increase the speed of the drone ;
-- `up_fact` : proportionality coefficients to apply to the command that increases the height of the drone, compared to the equivalent command to reduce it (in order to correct the effect of gravity).
-
-### About `keyboard_cmd` ###
-
-It allows you to publish commands on the topic `cmd_vel` and so to steer the drone. It is scheduled for azerty keyboards. To launch it, run :
-
-```
-#!sh
-rosrun hand_control keyboard_cmd
-```
-
-To increase/decrease the speed (there is an explication on the controlpanel) : a,z,e,r and w,x,c,v
-
-The informations of the drone are updated when a key is pressed.
-
-To quit : CTRL+C and press "Enter" to return to the console.
-
-# Problems - Possible improvements #
-
-- If commands are published on `cmd_vel` (from the Kinect for instance) after the launch of `ardrone.launch` and before the takeoff, then, after the takeoff, the drone seems to obey to commands published before the takeoff.
-
-- As written above, the display of navigation data on `keyboard_cmd` is only updated when a key is pressed, and can therefore stay fixed when the keyboard commander is not used.
-
-- The takeoff/landing is not controllable with the hand. The keyboard must be used (`keyboard_cmd` or `rostopic pub`) instead. We can correct this by creating two new thresholds, minimal and maximal, for the hand height : a very low hand would make the drone land and a very high hand would make the drone take off.
diff --git a/README-fr.md b/README-fr.md
new file mode 100644
index 0000000..7507ded
--- /dev/null
+++ b/README-fr.md
@@ -0,0 +1,142 @@
+# Installation #
+
+## Installation des dépendances ##
+```
+#!sh
+sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu trusty main" > /etc/apt/sources.list.d/ros-latest.list'
+wget https://raw.githubusercontent.com/ros/rosdistro/master/ros.key -O - | sudo apt-key add -
+sudo apt-get update
+sudo apt-get install ros-indigo-desktop-full ros-indigo-freenect-stack ros-indigo-ardrone-autonomy libncursesw5-dev
+```
+## Installation du paquet ##
+
+### Création d’un espace de travail catkin ###
+
+Par exemple :
+
+```
+#!sh
+source /opt/ros/indigo/setup.bash
+mkdir -p ~/hand_control_ws/src
+cd ~/hand_control_ws/src
+catkin_init_workspace
+```
+
+### Déplacement du code ###
+
+Renommer si besoin est le dossier qui contient ce fichier en `hand_control`, et le déplacer dans `~/hand_control_ws/src/`, ou dans le sous-dossier `src` de votre espace de travail catkin.
+
+## Compilation ##
+
+Il est ensuite possible de compiler :
+
+```
+#!sh
+cd ~/hand_control_ws # ou votre espace de travail catkin
+catkin_make
+```
+
+Puis pour pouvoir utiliser les commandes ROS, en remplaçant si besoin "hand_control_ws" par votre espace de travail catkin :
+
+```
+#!sh
+source /opt/ros/indigo/setup.bash
+source ~/hand_control_ws/devel/setup.bash
+echo "source /opt/ros/indigo/setup.bash" >> ~/.bashrc
+echo "source ~/hand_control_ws/devel/setup.bash" >> ~/.bashrc
+```
+
+# Utilisation #
+
+## Branchement de la Kinect et paramétrage ##
+
+1. Brancher la Kinect (sous tension) à l’ordinateur par USB ;
+2. Poser la Kinect sur le sol, pointant le plafond, votre bras devra être perpendiculaire à la Kinect pour pouvoir bien piloter le drone ;
+2. Lancer le "launchfile" kinect_commander.launch : `roslaunch hand_control kinect_commander.launch` ;
+3. Vérifier les paramètres du filtre :
+    - lancer rviz :  `rosrun rqt_rviz rqt_rviz`
+    - visualiser la sortie du filtrage (topic : `/filter/output` ; frame : `/camera_depth_optical_frame`) et repérer la main ;
+    - lancer rqt_reconfigure : `rosrun rqt_reconfigure rqt_reconfigure` pour :
+      - modifier les paramètres du filtre jusqu’à ne voir que les points de la main/gant/pancarte sur rviz (voir ci-dessous).
+      - modifier le paramètre `neutral_alt` du nœud `commander` à la hauteur souhaitée (en mètres). C’est la hauteur de la main qui correspondra à l’immobilité de l’altitude.
+    
+### Paramètres du filtre ###
+
+Les paramètres du filtre (modifiables avec `dynamic_reconfigure` et en particulier `rqt_reconfigure`) sont :
+
+* `z_max` : en mètres, altitude maximale de la main, doit être inférieure à la hauteur du plafond.
+* pour un gant ou un carton *coloré* (vert, bleu etc.), on a généralement :
+    - `hue` : par exemple 220 (bleu ciel) ou 150 (vert) ou 0 (rose/rouge) ;
+    - `delta_hue` : entre 10 et 20 ;
+    - `sat/val_min` : 0.0 ;
+    - `sat/val_max` : 1.0 ;
+* pour un gant *noir* :
+    - `hue` : 0 ;
+    - `delta_hue` : 180 ;
+    - `sat_min` : 0.0 ;
+    - `sat_max` : 1.0 ;
+    - `val_min` : 0.0 ;
+    - `val_max` : 0.3 (à modifier à votre convenance);
+
+### Autres paramètres ###
+
+Toujours avec `rqt_reconfigure`, cette fois pour le nœud `estimator` :
+- `reverse` : échange x et y (axes de la Kinect) (valeur par défaut pour une utilisation normale : faux [décoché])
+- `reverse_angle` : modifie l’axe choisi pour calculer l’angle de la main (valeur par défaut pour un utilisation normale : faux [décoché])
+
+## Connexion au drone et pilotage ##
+
+* Connecter l’ordinateur au réseau wifi du drone ;
+* Lancer le "launchfile" ardrone.launch : `roslaunch hand_control ardrone.launch` ;
+* Pour décoller : 
+    - soit `rostopic pub /ardrone/takeoff std_msgs/Empty` ;
+    - soit lancer le nœud keyboard_cmd : `rosrun hand_control keyboard_cmd` et utiliser la touche *t* du clavier.
+* Pour atterrir :
+    - soit `rostopic pub /ardrone/land std_msgs/Empty` ;
+    - soit, avec keyboard_cmd, utiliser la touche *b* du clavier.
+* Arrêt d’urgence :
+    - soit `rostopic pub /ardrone/reset std_msgs/Empty` ;
+    - soit, avec keyboard_cmd, utiliser la touche *g* du clavier.
+
+### Commande à la main ###
+
+* Avancer/reculer & translations latérales : inclinaison de la main ;
+* Tourner (rotation autours de l’axe z) : angle de l’axe de la main avec l’axe parallèle au sol et perpendiculaire à la Kinect ;
+* Monter/descendre : altitude de la main.
+
+### Options et paramètres de la commande ###
+
+Pour éditer les options de la commande, lancer si ce n’est déjà fait `rosrun rqt_reconfigure rqt_reconfigure` :
+
+- `max_curvature` : non utilisé pour l’instantt ;
+- `x/y/z/theta_minimal_deviation` : seuils à partir desquels le mouvement de la main est pris en compte. Tout mettre à 0.0 rend le comportement complétement linéaire.
+    * x, y : entre 0. et 1. (il s’agit des composantes x et y de la normale au plan);
+    * z : en mètre ;
+    * theta : en degrés.
+- `neutral_alt` : hauteur de la main qui correspond à l’immobilité de l’altitude du drone ;
+- `min_points_number` : nombre minimal de points (du nuage de points qui a servi à régresser le plan reçu) nécessaire pour qu’une commande soit envoyé au drone.
+- `angle/x/y/z_vel` : coefficients de proportionnalité à appliquer aux données en entrée pour établir la commande envoyée au drone. Les augmenter augmentera la vitesse du drone.
+- `up_fact` : coefficient de proportionnalité à appliquer à la commande augmentant l’altitude du drone, par rapport à la commande équivalente la diminuant (pour corriger l’effet de la gravité).
+
+### Notes sur `keyboard_cmd` ###
+
+Il permet de publier des commandes sur le topic `cmd_vel` et ainsi de piloter le drone. Il est prévu pour les claviers azerty. Pour le lancer :
+
+```
+#!sh
+rosrun hand_control keyboard_cmd
+```
+
+Pour augmenter/diminuer les vitesses (expliqué sur l’affichage du programme) : touches a,z,e,r et w,x,c,v
+
+L’affichage des informations reçues du drone n’est mise à jour qu’à l’occasion de l’appui sur une touche. 
+
+Pour quitter : Ctr+C, et appui sur "Entrée" pour retrouver l’affichage de la console.
+
+# Problème(s) rencontré(s) — Améliorations souhaitables #
+
+- Si des commandes sont publiées sur `cmd_vel` (depuis la Kinect par exemple) après le lancement du fichier `ardrone.launch` et avant le décollage du drone, alors, après le décollage, de drone semble obéir aux commandes publiées avant le décollage.
+
+- Comme écrit plus haut, l’affichage des informations reçues du drone sur `keyboard_cmd` n’est mise à jour qu’à l’occasion de l’appui sur une touche, et peut donc rester fixe quand on n’utilise pas la commande au clavier.
+
+- Le décollage/atterrissage n’est pas possible à commander avec la main. Il faut utiliser le clavier (`keyboard_cmd` ou `rostopic pub`) à la place. Il est possible de de remédier à cela en créant deux nouveaux seuils, minimaux et maximaux, pour la hauteur de la main : une main très basse ferait atterrir le drone, une main très haute le ferait décoller.
diff --git a/README.md b/README.md
index 7507ded..541f4bf 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,8 @@
 # Installation #
 
-## Installation des dépendances ##
+This package was developped with the Indigo version of ROS.
+
+## Dependencies installation ##
 ```
 #!sh
 sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu trusty main" > /etc/apt/sources.list.d/ros-latest.list'
@@ -8,11 +10,11 @@ wget https://raw.githubusercontent.com/ros/rosdistro/master/ros.key -O - | sudo
 sudo apt-get update
 sudo apt-get install ros-indigo-desktop-full ros-indigo-freenect-stack ros-indigo-ardrone-autonomy libncursesw5-dev
 ```
-## Installation du paquet ##
+## Package installation ##
 
-### Création d’un espace de travail catkin ###
+### Catkin workspace creation ###
 
-Par exemple :
+For instance :
 
 ```
 #!sh
@@ -22,21 +24,21 @@ cd ~/hand_control_ws/src
 catkin_init_workspace
 ```
 
-### Déplacement du code ###
+### Code location ###
 
-Renommer si besoin est le dossier qui contient ce fichier en `hand_control`, et le déplacer dans `~/hand_control_ws/src/`, ou dans le sous-dossier `src` de votre espace de travail catkin.
+If necessary, rename the folder with the file named `hand_control`, and move it in `~/hand_control_ws/src/` or in the subfolder `src` of your catkin workspace.
 
 ## Compilation ##
 
-Il est ensuite possible de compiler :
+You're now able to compile :
 
 ```
 #!sh
-cd ~/hand_control_ws # ou votre espace de travail catkin
+cd ~/hand_control_ws # or your catkin workspace
 catkin_make
 ```
 
-Puis pour pouvoir utiliser les commandes ROS, en remplaçant si besoin "hand_control_ws" par votre espace de travail catkin :
+Then you can run the following commands to be able to use the ROS commands. If necessary replace "hand_control_ws" by the name of your catkin workspace.
 
 ```
 #!sh
@@ -46,97 +48,97 @@ echo "source /opt/ros/indigo/setup.bash" >> ~/.bashrc
 echo "source ~/hand_control_ws/devel/setup.bash" >> ~/.bashrc
 ```
 
-# Utilisation #
+# Use #
 
-## Branchement de la Kinect et paramétrage ##
+## Connection and setting up of the Kinect ##
 
-1. Brancher la Kinect (sous tension) à l’ordinateur par USB ;
-2. Poser la Kinect sur le sol, pointant le plafond, votre bras devra être perpendiculaire à la Kinect pour pouvoir bien piloter le drone ;
-2. Lancer le "launchfile" kinect_commander.launch : `roslaunch hand_control kinect_commander.launch` ;
-3. Vérifier les paramètres du filtre :
-    - lancer rviz :  `rosrun rqt_rviz rqt_rviz`
-    - visualiser la sortie du filtrage (topic : `/filter/output` ; frame : `/camera_depth_optical_frame`) et repérer la main ;
-    - lancer rqt_reconfigure : `rosrun rqt_reconfigure rqt_reconfigure` pour :
-      - modifier les paramètres du filtre jusqu’à ne voir que les points de la main/gant/pancarte sur rviz (voir ci-dessous).
-      - modifier le paramètre `neutral_alt` du nœud `commander` à la hauteur souhaitée (en mètres). C’est la hauteur de la main qui correspondra à l’immobilité de l’altitude.
+1. Connect the Kinect (under voltage) to the computer via USB ;
+2. Put the Kinect on the ground, pointed toward the roof ; be aware that your arm must be perpendicular to the Kinect in order to control the drone properly ;
+2. Launch the "launchfile" kinect_commander.launch : `roslaunch hand_control kinect_commander.launch` ;
+3. Check the drone parameters :
+    - launch rviz :  `rosrun rqt_rviz rqt_rviz`
+    - display the output of the filtering (topic : `/filter/output` ; frame : `/camera_depth_optical_frame`) and locate the hand ;
+    - launch rqt_reconfigure : `rosrun rqt_reconfigure rqt_reconfigure` in order to :
+      - change the filter parameters until you only see the points of the hand/glove/panel on rviz (see above).
+      - change the parameter `neutral_alt` of the node `commander` to the wanted height (in meters), correponding to the height of the hand for which the height of the drone will be stable.
     
-### Paramètres du filtre ###
+### Parameters of the filter ###
 
-Les paramètres du filtre (modifiables avec `dynamic_reconfigure` et en particulier `rqt_reconfigure`) sont :
+The parameters of the filter (that can be changed thanks to `dynamic_reconfigure` and in particular `rqt_reconfigure`) are :
 
-* `z_max` : en mètres, altitude maximale de la main, doit être inférieure à la hauteur du plafond.
-* pour un gant ou un carton *coloré* (vert, bleu etc.), on a généralement :
-    - `hue` : par exemple 220 (bleu ciel) ou 150 (vert) ou 0 (rose/rouge) ;
-    - `delta_hue` : entre 10 et 20 ;
+* `z_max` : in meters, maximal height of the hand. It must be lower than the height of the roof.
+* for a glove or a *colored* panel (green, blue, etc.), we generaly have :
+    - `hue` : for example 220 (sky blue) or 150 (green) or 0 (pink/red) ;
+    - `delta_hue` : between 10 and 20 ;
     - `sat/val_min` : 0.0 ;
     - `sat/val_max` : 1.0 ;
-* pour un gant *noir* :
+* for a *black* glove :
     - `hue` : 0 ;
     - `delta_hue` : 180 ;
     - `sat_min` : 0.0 ;
     - `sat_max` : 1.0 ;
     - `val_min` : 0.0 ;
-    - `val_max` : 0.3 (à modifier à votre convenance);
+    - `val_max` : 0.3 (at your convenience);
 
-### Autres paramètres ###
+### Other parameters ###
 
-Toujours avec `rqt_reconfigure`, cette fois pour le nœud `estimator` :
-- `reverse` : échange x et y (axes de la Kinect) (valeur par défaut pour une utilisation normale : faux [décoché])
-- `reverse_angle` : modifie l’axe choisi pour calculer l’angle de la main (valeur par défaut pour un utilisation normale : faux [décoché])
+Always with `rqt_reconfigure`, but with the `estimator` node :
+- `reverse` : swap x and y, the axes of the Kinect (default : false, ie. unchecked)
+- `reverse_angle` : change the angle choosen for the compute of the angle of the hand (default : false, ie. unchecked)
 
-## Connexion au drone et pilotage ##
+## Connection to the drone and steering ##
 
-* Connecter l’ordinateur au réseau wifi du drone ;
-* Lancer le "launchfile" ardrone.launch : `roslaunch hand_control ardrone.launch` ;
-* Pour décoller : 
-    - soit `rostopic pub /ardrone/takeoff std_msgs/Empty` ;
-    - soit lancer le nœud keyboard_cmd : `rosrun hand_control keyboard_cmd` et utiliser la touche *t* du clavier.
-* Pour atterrir :
-    - soit `rostopic pub /ardrone/land std_msgs/Empty` ;
-    - soit, avec keyboard_cmd, utiliser la touche *b* du clavier.
-* Arrêt d’urgence :
-    - soit `rostopic pub /ardrone/reset std_msgs/Empty` ;
-    - soit, avec keyboard_cmd, utiliser la touche *g* du clavier.
+* Connect the computer to the wifi network of the drone ;
+* Launch the "launchfile" ardrone.launch : `roslaunch hand_control ardrone.launch` ;
+* Taking off : 
+    - whether `rostopic pub /ardrone/takeoff std_msgs/Empty` ;
+    - or launch the node keyboard_cmd : `rosrun hand_control keyboard_cmd` and use *t* on the keyboard.
+* Landing :
+    - whether `rostopic pub /ardrone/land std_msgs/Empty` ;
+    - or, launch the node keyboard_cmd, and use *b* on the keyboard.
+* Emergency stop :
+    - whether `rostopic pub /ardrone/reset std_msgs/Empty` ;
+    - or, launch the node keyboard_cmd, and use *g* on the keyboard.
 
-### Commande à la main ###
+### Hand steering ###
 
-* Avancer/reculer & translations latérales : inclinaison de la main ;
-* Tourner (rotation autours de l’axe z) : angle de l’axe de la main avec l’axe parallèle au sol et perpendiculaire à la Kinect ;
-* Monter/descendre : altitude de la main.
+* Forward/backward & side translations : hand tilt ;
+* Rotate (around the vertical axis z) : angle of the hand with the the axis parallel to the ground and perpendicular to the kinect ;
+* go up/go down : hand height.
 
-### Options et paramètres de la commande ###
+### Options and parameters of the command ###
 
-Pour éditer les options de la commande, lancer si ce n’est déjà fait `rosrun rqt_reconfigure rqt_reconfigure` :
+To edit the options of the command, change (if not already) `rosrun rqt_reconfigure rqt_reconfigure` :
 
-- `max_curvature` : non utilisé pour l’instantt ;
-- `x/y/z/theta_minimal_deviation` : seuils à partir desquels le mouvement de la main est pris en compte. Tout mettre à 0.0 rend le comportement complétement linéaire.
-    * x, y : entre 0. et 1. (il s’agit des composantes x et y de la normale au plan);
-    * z : en mètre ;
-    * theta : en degrés.
-- `neutral_alt` : hauteur de la main qui correspond à l’immobilité de l’altitude du drone ;
-- `min_points_number` : nombre minimal de points (du nuage de points qui a servi à régresser le plan reçu) nécessaire pour qu’une commande soit envoyé au drone.
-- `angle/x/y/z_vel` : coefficients de proportionnalité à appliquer aux données en entrée pour établir la commande envoyée au drone. Les augmenter augmentera la vitesse du drone.
-- `up_fact` : coefficient de proportionnalité à appliquer à la commande augmentant l’altitude du drone, par rapport à la commande équivalente la diminuant (pour corriger l’effet de la gravité).
+- `max_curvature` : not used for the moment ;
+- `x/y/z/theta_minimal_deviation` : thresholds required above which the movement of the hand is not taken into account. If all are 0.0, the drone responds linearly.
+    * x, y : between 0. and 1. (corresponding to the x and y of the normal to the plane);
+    * z : in meters ;
+    * theta : in degrees.
+- `neutral_alt` : height of the hand for the immobility of the height of the drone ;
+- `min_points_number` : minimal number of points (for the point cloud used for the regression) necessary in order to send a command to the drone ;
+- `angle/x/y/z_vel` : proportionality coefficients to apply to the inputs in order to establish the command sent to the drone. Increase it will increase the speed of the drone ;
+- `up_fact` : proportionality coefficients to apply to the command that increases the height of the drone, compared to the equivalent command to reduce it (in order to correct the effect of gravity).
 
-### Notes sur `keyboard_cmd` ###
+### About `keyboard_cmd` ###
 
-Il permet de publier des commandes sur le topic `cmd_vel` et ainsi de piloter le drone. Il est prévu pour les claviers azerty. Pour le lancer :
+It allows you to publish commands on the topic `cmd_vel` and so to steer the drone. It is scheduled for azerty keyboards. To launch it, run :
 
 ```
 #!sh
 rosrun hand_control keyboard_cmd
 ```
 
-Pour augmenter/diminuer les vitesses (expliqué sur l’affichage du programme) : touches a,z,e,r et w,x,c,v
+To increase/decrease the speed (there is an explication on the controlpanel) : a,z,e,r and w,x,c,v
 
-L’affichage des informations reçues du drone n’est mise à jour qu’à l’occasion de l’appui sur une touche. 
+The informations of the drone are updated when a key is pressed.
 
-Pour quitter : Ctr+C, et appui sur "Entrée" pour retrouver l’affichage de la console.
+To quit : CTRL+C and press "Enter" to return to the console.
 
-# Problème(s) rencontré(s) — Améliorations souhaitables #
+# Problems - Possible improvements #
 
-- Si des commandes sont publiées sur `cmd_vel` (depuis la Kinect par exemple) après le lancement du fichier `ardrone.launch` et avant le décollage du drone, alors, après le décollage, de drone semble obéir aux commandes publiées avant le décollage.
+- If commands are published on `cmd_vel` (from the Kinect for instance) after the launch of `ardrone.launch` and before the takeoff, then, after the takeoff, the drone seems to obey to commands published before the takeoff.
 
-- Comme écrit plus haut, l’affichage des informations reçues du drone sur `keyboard_cmd` n’est mise à jour qu’à l’occasion de l’appui sur une touche, et peut donc rester fixe quand on n’utilise pas la commande au clavier.
+- As written above, the display of navigation data on `keyboard_cmd` is only updated when a key is pressed, and can therefore stay fixed when the keyboard commander is not used.
 
-- Le décollage/atterrissage n’est pas possible à commander avec la main. Il faut utiliser le clavier (`keyboard_cmd` ou `rostopic pub`) à la place. Il est possible de de remédier à cela en créant deux nouveaux seuils, minimaux et maximaux, pour la hauteur de la main : une main très basse ferait atterrir le drone, une main très haute le ferait décoller.
+- The takeoff/landing is not controllable with the hand. The keyboard must be used (`keyboard_cmd` or `rostopic pub`) instead. We can correct this by creating two new thresholds, minimal and maximal, for the hand height : a very low hand would make the drone land and a very high hand would make the drone take off.