Archives par étiquette : système autonome

BateauRaspberry : un bateau entièrement fait main, piloté par un Pi (màj)

Il y a quelques temps j’ai été contacté par Tim, un lecteur de MagdiBlog, pour son projet de bateau piloté par un Raspberry Pi 🙂

Après plusieurs échanges de mails, et quelques semaines (mois ?) de travail, Tim est arrivé au bout de son projet :

tim_bateau_telecommande_raspberry_piSon projet, très complet, aborde plusieurs problématiques entre la gestion des moteurs et servos moteurs, le pilotage à distance via WiFi, la capture d’image, etc…

Continuer la lecture

PiTimeLapse – 13 – Premier retour d’expérience et améliorations

J’ai pu tester le dispositif pendant une semaine sur notre terrain. En mode commando avec une petite pelle et une lampe frontale, tout l’équipement dans un sac noir, je suis allé enterrer le paquet au fond du terrain un dimanche soir, et suis revenu le cherché le dimanche suivant.

IMG_5676J’ai imprimé une petite note explicative sur le dessus de la boite contenant le dispositif avec mes coordonnées, au cas où quelqu’un tomberait dessus…

Après avoir armé le système et synchronisé l’horloge du circuit d’alimentation, j’ai creusé un trou au fond du terrain pour y cacher la boite. La webcam est attachée sur une clôture à environ un mètre du sol. Il n’y a plus qu’à croiser les doigts pour que tout se passe bien… Le lendemain, je devrais recevoir les premières images sur le serveur de monitoring à partir de 8h. Bizarrement, je sens une légère angoisse en laissant tout ce matériel dans la nature :/

Continuer la lecture

GPIO – Servos moteurs, joypad et WiFi

IMG_5494

Nous allons voir dans cet article comment réaliser une station de pilotage à distance pour commander des servos moteurs, à l’aide d’un Raspberry Pi, d’un joypad et d’un lien WiFi. Dans cet exemple j’uitiliserai un eeePC 901 pour la station de pilotage, mais il est tout à fait possible d’utiliser un deuxième Raspberry Pi.

Voici un schéma global :

pi joystick servoLa construction de ce dispositif se fait en trois étapes :

  1. Contrôle des servos moteurs par le Pi
  2. Utilisation du joypad
  3. Envoi des commandes à distance par wifi

Liste du matériel utilisé dans cet article

 

1 – Contrôle des servos moteurs par le Pi

Pour piloter plusieurs servos moteurs avec un Pi, nous n’avons d’autre choix que de passer par une carte contrôleur. Le site Adafruit propose justement un circuit permettant de contrôler jusqu’à 16 servos moteurs en utilisant le bus I²C (disponible sur le GPIO du Pi comme expliqué dans cet article GPIO – Entrée en matière).

imageVous pouvez acheter ce circuit directement sur le site d’Adafruit : Adafruit 16-Channel 12-bit PWM/Servo Driver – I2C interface – PCA9685

imageVous devrez sortir votre fer et souder les broches sur le circuit imprimé 🙂 Un bornier est prévu pour connecter une source d’alimentation. J’utilise un bloc coupleur de pile avec 4 piles AA pour fournir une tension de 6V, parfait pour alimenter mes servos moteurs.

Côté servos, je dispose de deux gros FUTABA S3010 et d’un minuscule FUTABA S3114.

Le branchement de la carte sur le Pi peut se faire simplement à l’aide de wire jumpers. Il suffit de connecter l’alimentation (3,3V et la masse/ground) ainsi que les broches SCL et SDA comme sur le schéma ci-dessous :

branchement_16cUne fois les branchements effectués, il convient d’activer le support de l’I²C sur le Raspberry Pi. Ceci se fait en deux étapes :

1 – Editez le fichier /etc/modules et ajoutez les deux lignes suivantes :

i2c-bcm2708
i2c-dev

2 – Editez ensuite le fichier /etc/modprobe.d/raspi-blacklist.conf et commentez les deux lignes suivantes (en ajoutant # au début de ces deux lignes) :

# blacklist spi-bcm2708
# blacklist i2c-bcm2708

Pour finir, installez l’outil i2c-tools et redémarrez le Pi :

apt-get install i2c-tools
shutdown -r now

Pour vérifer que la carte est bien reconnue par le Pi, lancez la commande suivante :

i2cdetect -y 1 # pour la révision 2 du Pi

ou

i2cdetect -y 0 # pour la première version du Pi

Vous devriez obtenir ce résultat :

root@raspberrypi:~# i2cdetect -y 1
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: 40 -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: 70 -- -- -- -- -- -- --

Bien ! Nous allons maintenant écrire le programme en Python qui va nous permettre de piloter ces servos moteurs. Python est installé par défaut sur Raspbian, il ne manque que certains paquets :

apt-get install python-dev python-rpi.gpio python-smbus

Adafruit propose une librairie Python qui permet de dialoguer facilement avec les différents composants distribués par son site. Nous n’allons pas nous en priver 🙂 Pour télécharger la dernière version disponible de cette librairie, il suffit d’en récupérer les sources sur le dépôt GIT :

git clone https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code.git

La partie qui nous intéresse ici se trouve dans le répertoire Adafruit-Raspberry-Pi-Python-Code/Adafruit_PWM_Servo_Driver.

Dans un premier temps, voici un petit script qui permet de tester les servos test_servo.py :

#!/usr/bin/python

from Adafruit_PWM_Servo_Driver import PWM
import sys

pwm = PWM(0x40, debug=True)
pwm.setPWMFreq(60)

pwm.setPWM(int(sys.argv[1]), 0, int(sys.argv[2]))

Pensez à rendre ce script exécutable grâce à la commande chmod 755 test_servo.py

Ce script prend deux paramètres :

  • l’id du port contrôlant un servo de 0 à 15
  • une valeur, généralement entre 150 et 600 qui détermine la position que doit prendre le servo

Exemples pour commander le servo branché sur le premier port (ayant pour id 0) :

./test_servo.py 0 480
./test_servo.py 0 240

Et voilà, si tout s’est bien passé, vous devriez pouvoir piloter vos servos de cette manière. Nous verrons plus loin dans cet article comment les piloter avec un joypad et à distance 🙂

Note : Je ne sais absolument pas pourquoi le troisième paramètre de la fonction setPWM() doit être entre 150 et 600… De même, je ne sais pas à quoi correspond le deuxième paramètre attendu par cette fonction. Si quelqu’un connaît la réponse, merci de nous expliquer cela en commentaire de cet article 🙂

2 – Utilisation du joypad

26-127-505-02Je dispose d’un magnifique joypad USB, modèle Saitek P990 munis de deux mini-joysticks ou « chapeaux chinois ». Nous allons utiliser ces deux joysticks pour piloter nos servos.

Un joystick qu’est ce que c’est ? En fait, c’est simplement un potentiomètre dont la valeur (la résistance) est interprétée et traduite en nombre. Sur ce modèle de joypad, les valeurs sont échantillonnées de 0 à 1023 (soit 1024 valeurs possibles). Pour obtenir deux axes, il y a deux potentiomètres par joystick. Avec deux joysticks, nous avons donc de quoi piloter indépendamment 4 servos 🙂

La librairie Python evdev permet d’interagir facilement avec les événements déclenchés par des périphériques USB. Pour l’installer :

apt-get install python-pip python-dev
pip install evdev

Avant d’écrire un script Python qui sache interpréter les actions de ces joysticks, vous devez connaître l’identifiant « event » attribué par le système au moment où vous branchez votre joypad USB.

lsusb
Bus 001 Device 003: ID 05e3:0608 Genesys Logic, Inc. USB-2.0 4-Port HUB
Bus 001 Device 005: ID 05e3:0505 Genesys Logic, Inc.
Bus 002 Device 003: ID 06a3:040b Saitek PLC P990 Dual Analog Pad
Bus 005 Device 002: ID 0b05:b700 ASUSTek Computer, Inc. Broadcom Bluetooth 2.1
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 002 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 003 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 004 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 005 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 001 Device 006: ID 11b0:6148 ATECH FLASH TECHNOLOGY
Bus 001 Device 007: ID 05af:3062 Jing-Mold Enterprise Co., Ltd Cordless Keyboard
Bus 001 Device 008: ID 046d:c016 Logitech, Inc. Optical Wheel Mouse

Mon joypad est bien reconnu par le système avec la dénomination : « Saitek PLC P990 Dual Analog Pad« .

cat /proc/bus/input/devices

Cherchez la référence à votre joypad et repérez l’identifiant « event », ici nous avons l’identifiant « event6« .

[...]

I: Bus=0003 Vendor=06a3 Product=040b Version=0100
N: Name="Saitek P990 Dual Analog Pad"
P: Phys=usb-0000:00:1d.0-2/input0
S: Sysfs=/devices/pci0000:00/0000:00:1d.0/usb2/2-2/2-2:1.0/input/input15
U: Uniq=
H: Handlers=event6 js0
B: PROP=0
B: EV=1b
B: KEY=3fff 0 0 0 0 0 0 0 0 0
B: ABS=30027
B: MSC=10

[...]

A chaque fois que l’on va presser un bouton sur le joypad, ou actionner un de ses joysticks, un événement sera déclenché. Il s’agit donc de surveiller en permanence les événements déclenchés et d’agir en fonction. Voici maintenant un petit script Python qui permet de tester votre joypad et d’identifier les différents événements liés à chaque joystick et chaque bouton : test_joypad.py

#!/usr/bin/python

from evdev import InputDevice, categorize, ecodes
from time import sleep
from datetime import date
import os, sys, socket

dev = InputDevice('/dev/input/event6') # reprendre le même identifiant "event"
print(dev)

for event in dev.read_loop(): # boucle qui surveille l'arrivée d'un événement
  e_code=event.code
  e_type=event.type
  e_value=event.value
  print(str(e_type)+' - '+str(e_code)+' - '+str(e_value))

A chaque fois que vous toucherez quelque chose sur votre joypad, ce script affichera trois variables, e_code, e_type et e_value :

./test_joystick.py
device /dev/input/event6, name "Saitek P990 Dual Analog Pad", phys "usb-0000:00:1d.0-2/input0"
3 - 0 - 508
3 - 0 - 412
3 - 0 - 347
3 - 0 - 391
3 - 0 - 457
3 - 0 - 511
3 - 1 - 602
3 - 1 - 701
3 - 1 - 771
3 - 1 - 659
3 - 1 - 561
3 - 1 - 511

Voilà ce que j’obtiens en actionnant le joystick gauche de mon joypad, identifié par l’e_code 3. Dans l’axes des X, j’obtiens un e_type 0, et un e_type 1 pour l’axe des Y. Lorsque je relâche le joystick en position centrale, les valeurs sont proches de 512 (valeur médiane entre 0 et 1023). Ces caractéristiques sont propres à ce modèle de joypad, mais le principe de fonctionnement est le même pour tous 🙂 Ce petit script vous permettra de noter l’e_code et l’e_type de chaque bouton et joystick que vous voulez utiliser.

Pour ma part, j’ai trois servos à piloter, et je dispose de deux joysticks avec chacun deux axes. J’utiliserai l’axe X du joystick gauche (e_code 3, e_type 0) pour piloter le servo 1. L’axe Y du joystick gauche (e_code 3, e_type 1) pour piloter le servo 2. Et enfin l’axe X joystick droit (e_code 3, e_type 5) pour piloter le servo 3 🙂

A partir de là, vous pouvez facilement imaginer associer le servo 1 au roulis d’un avion, le servo 2 au tangage et le servo 3 au lacet par exemple 🙂

La dernière étape consiste à envoyer les commandes du joypad, branché sur la station de pilotage, au Raspberry Pi qui répercutera les ordres sur ses servos 🙂

3 – Envoi des commandes à distance par wifi

Nous avons d’un côté un script Python qui tourne sur un Raspberry Pi qui a pour rôle de piloter des servos. De l’autre, nous avons un eeePC (ou autre machine…), qui exécute un second script Python dont le but est d’interpréter les commandes envoyées par un joypad. Il s’agit maintenant de faire communiquer ces deux scripts entre eux, ce que nous pouvons facilement faire grâce aux sockets 🙂

Sans trop rentrer dans les détails, il s’agit d’ouvrir une socket au niveau du script qui s’exécute sur le Pi afin qu’il soit à l’écoute de messages envoyés par le script côté « station de pilotage ». Le script côté « station de pilotage » se connecte à cette socket en passant par le réseau IP (via WiFi), et envoie les commandes déclenchées par le joypad.

Côté Raspberry Pi :

#!/usr/bin/python

from Adafruit_PWM_Servo_Driver import PWM
import sys, os, socket

listen_address = ('0.0.0.0', 12800) # écoute sur toutes les interface sur le port 12800

srv_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # protocole UDP
srv_socket.bind(listen_address)
print "server enabled"

pwm = PWM(0x40, debug=True) # initialisation de la carte contrôleur
pwm.setPWMFreq(60)

while True:
  query, clt_address = srv_socket.recvfrom(1024) # écoute les message
  order=query.split('_') # on découpe les messages reçus
  servo=order[0]
  pos=order[1]
  print str(query)+' - '+str(servo)+' - '+str(pos) # on affiche les infos
  pwm.setPWM(int(servo), 0, int(pos)) # on envoie la commande au servo
sys.exit(0)

Côté Station de pilotage :

#!/usr/bin/python

from evdev import InputDevice, categorize, ecodes
from time import sleep
from datetime import date
import os, sys, socket

now = date.today()
print(now)

clt_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # protocole UDP
srv_address = ('192.168.101.27', 12800) # on vise l'adresse IP du Pi sur le port 12800

dev = InputDevice('/dev/input/event6') # initialisation du joypad
print(dev)

def convertAxis (value, axis_max): # fonction qui convertie les valeurs des joystick
  facteur=axis_max/490
  new_value=int(round((value/facteur)+150, 0))
  return new_value

for event in dev.read_loop(): # pour chaque événement détecté
  e_code=event.code
  e_type=event.type
  e_value=event.value
  print(str(e_type)+' - '+str(e_code)+' - '+str(e_value))
  if e_type == 3:
    if e_code == 0: # à destination du servo 1
      servo_pos=str(convertAxis (e_value, 1024))
      clt_socket.sendto("0_"+servo_pos, srv_address)
    elif e_code == 1: # à destination du servo 2
      servo_pos=str(convertAxis (e_value, 1024))
      clt_socket.sendto("1_"+servo_pos, srv_address)
    elif e_code == 5: # à destination du servo 3
      servo_pos=str(convertAxis (e_value, 512))
      clt_socket.sendto("2_"+servo_pos, srv_address)

Conclusions

En déclinant ce principe, vous pouvez piloter de nombreux servos moteurs à distance et commencer à envisager la construction systèmes complexes comme des robots ou des drones 🙂

En parlant de drone, ces articles relatifs au GPIO me serviront à construire un drone avion, comme expliqué ici : Raspberry Pi BOA Drone 🙂

Cependant, certaines zones d’ombre persistes, notamment sur le pilotage de servos. L’utilisation de la lib distribuée par Adafruit évite de se poser de question, cela fonctionne immédiatement. La contre partie, c’est qu’on ne comprend pas forcément tout ce qui se passe. Aussi, j’invite les lecteurs de ce blog à intervenir en commentaire de cet article afin d’apporter des informations complémentaires, des idées ou simplement des remarques 🙂

Merci à vous 🙂

GPIO – Entrée en matière

Grâce à son port GPIO (General Purpose Input/Output), le Raspberry Pi peut interagir avec le monde réel en communiquant avec des capteurs, des moteurs, et un tas d’autres composants électroniques (sondes de température, LEDs, capteurs gyroscopiques, boussoles, GPS, servos moteurs, récepteurs IR/RF…). De la petite commande relais pour piloter vos guirlandes de Noël, au robot, en passant par la station météo et le drone, les possibilités sont sans limites, ou presque 🙂

pi_gpio

Le matériel de base

Qui dit GPIO, dit composants électroniques 🙂 Il va de soit que des compétences en électronique de base sont requises. De plus, il convient de s’équiper d’un minimum de matériel afin de pouvoir tester et réaliser de petits circuits.

imageVoici, selon moi, le stricte minimum du matériel à acheter avant de démarrer :

Le port GPIO

Le port GPIO du Pi comporte 26 broches qui peuvent être utilisées de manières différentes. Le schéma ci-dessous (publié par le site eLinux) montre le rôle de chaque broches ainsi que les protocoles qu’elles supportent.

GPIOsOn distingue 7 types de broches et usages qu’on peut en faire :

Ces différents « bus » et « protocoles » permettent d’interfacer le Pi avec d’autres cartes, modules ou composants électroniques.

Les exemples d’utilisation les plus simples des broches de type GPIO sont l’allumage et l’extinction d’une LED, l’interaction avec un bouton/interrupteur, le contrôle de relais, etc,…

L’I²C, le SPI, l’UART et le PWM permettent quant à eux de communiquer avec des microcontrôleurs pour réaliser des opérations plus complexes telles que le contrôle de servos moteurs, la lecture de mesures prises par des capteurs etc,…

Alimentation des broches

Avant toute chose il est important de préciser les broches du port GPIO sont alimentées en 3,3V. Seules les deux broches d’arrivée de courant (en rouge) fournissent une tension de 5V.

Ce qui veut dire qu’en mode ouput (sortie) la tension fournie par une broche est de 3,3V et délivrera un courant de 50mA max. Vous devrez donc vous assurer que les composants que vous reliez à ces broches supportent se type de courant. En mode input (entrée), une broche ne tolérera qu’une tension maximum de 3,3V ! Vous devrez donc toujours faire attention à vos branchements pour éviter d’endommager votre Raspberry Pi 🙂 

En outre, il est préférable d’utiliser une source d’alimentation tierce pour les composants et modules électroniques que vous souhaitez ajouter dans votre circuit. En effet, le Raspberry Pi n’est pas suffisamment robuste pour alimenter correctement et sans danger des circuits électroniques. Pour allumer une LED pas de problème, mais pour faire tourner un moteur, prévoyez une source d’alimentation dédiée.

Dans l’absolue, et pour des raisons évidentes de sécurité, je conseille d’utiliser des piles plutôt que de travailler directement sur le secteur (d’où le coupleur de pile dans la liste du matériel de base) 😉

Prendre la main sur le port GPIO

WiringPi est un outil qui permet de contrôler les différentes broches du port GPIO. Pour installer WiringPi :

git clone git://git.drogon.net/wiringPi
cd ./wiringPi
./build

A partir de là, vous pouvez obtenir l’état de toutes les broches grâce à la commande :

gpio readall

Ce qui devrait vous afficher un tableau de ce type :

readallChaque ligne du tableau représente une broche du port GPIO et vous indique sont mode IN/OUT (entrée/sortie) et sont état/valeur 0/1 (low/high). La colonne GPIO représente le numéro de la broche tel que décrit sur le schéma en haut de cet article. La colonne wiringPi représente le numéro de broche que vous devez utiliser en utilisant la commande gpio.

De manière très simplifiée, si vous voulez allumer une LED, vous devez mettre la broche en mode sortie/output. En mettant l’état de la broche à 1/up, la LED s’allumera. Si vous voulez savoir si un bouton/interrupteur est ouvert ou fermé, vous devez mettre la broche en mode entrée/input. Si vous lisez la valeur 0/down, alors l’interrupteur est ouvert. Si vous lisez la valeur 1/up, alors l’interrupteur est fermé 🙂 Dans la pratique c’est un tout petit peu plus complexe, mais il s’agit là de comprendre le principe.

Pour chaque broche, vous pouvez changer le mode entrée/sortie ou in/out grâce à la commande (<pin> étant le numéro de la broche ciblée) :

gpio mode <pin> in
gpio mode <pin> out

En mode entrée/read vous pouvez lire l’état d’une broche avec la commande :

gpio read <pin>

En mode sortie/write, vous pouvez changer l’état d’une grâce à la commande :

gpio write <pin> 0
gpio write <pin> 1

Pour plus d’information sur la commande gpio : http://wiringpi.com/the-gpio-utility/

Quelques exemples de montages simples

En cherchant un peu sur le web vous trouverez une multitude de tutos qui expliquent comment faire de petits montages simples. Inutile de plagier la terre entière en recopiant ici ces tutos, je préfère vous donner directement quelques liens :

1 – Raspberry Pi BOA Drone

Pi-BOA-Drone_small_45C’est avec un grand plaisir que j’attaque ce nouveau projet : un drone avion longue distance, piloté par un Raspberry Pi, baptisé Pi BOA Drone 🙂 L’objectif (impossible ? ambitieux ?) de ce projet est d’effectuer un vol de 400 kms (entre Lille et Metz) en parfaite autonomie (auto-pilote) !

Les avions et la robotique m’ont toujours passionné, et le mariage de ces deux mondes avec l’avènement des drones, tant au niveau militaire que « domestique », m’a donné envie de realiser mon propre drone. Il y a quelques années, cela relevait du fantasme, les composants et matérieux étaient chers et il n’existait pas de « système » suffisamment compact et accessible pour pouvoir l’intégrer à dans « object volant » sans se ruiner. L’arrivée du Raspberry Pi a changé la donne 😉

Les drones actuels

parrot_ar_droneUn des premiers drones a avoir été présenté au grand public est l’AR Drone de Parrot. Vendu en France à partir de 2010 pour près de 350€, il est, je pense, à l’origine de nombreux autres projets volants de la famille des multicopters/multirotors.

Soyons clair, il s’agit en fait d’un « hélicoptère » télécommandé amélioré. Je vais être vache, mais prenez un petit hélicoptère comme le Silverlit Sky Unicorn vendu une trentaine d’euros, ajoutez y une mini caméra, et vous obtenez le même résultat : Un objet volant télécommandé capable de faire du vol stationnaire tout en capturant une vidéo. Même si la technologie embarquée dans l’AR Drone est beaucoup plus complexe (gestion des rotors, capteurs, etc,…), le résultat est sensiblement le même… En disant cela, je ne cherche pas à dénigrer quoi que ce soit, j’essaie simplement de démystifier le sujet pour montrer qu’un drone n’est qu’un ensemble de systèmes simples 🙂

IMG_5459J’ai ce petit hélicoptère (le Silverlit Sky Unicorn) depuis plusieurs mois, et je dois dire que je m’amuse beaucoup avec 😀 Il m’a énormément inspiré pour ce projet de drone. Si vous vous lancez dans l’aventure, je vous conseille de vous acheter ce genre de jouet très abordable ne serait ce que pour vous familiariser avec la chose et vous rendre compte des problématiques liées au vol d’un objet 🙂

Revenons à l’AR Drone et à son système électronique embarqué. La première génération de la bête est pilotée par un processeur ARM9 qui fait tourner un OS Linux avec 128 Mo de RAM, le tout étant télécommandé via un lien WiFi. Cela ne vous rappelle rien ? Le tableau ci-dessous vous mettra sur la voix :

Système embarqué
AR Drone v1
Raspberry Pi
Modèle B 512
Processeur ARM9 468 MHz ARM11 700 MHz
RAM 128 Mo 512 Mo
Connectique USB, WiFi USB, Ethernet, GPIO
OS Linux Linux

Tout à fait ! C’est un système très semblable au Raspberry Pi qui fait voler l’AR Drone 🙂 Ce constat permet de valider l’hypothèse qu’il est possible de faire voler quelque chose grace à un Pi 🙂

Les drones multirotors

hexaphoto2Quand on dit « drone », on pense souvent aux drones de la famille des multicopters/multirotors, c’est à dire un « hélicoptère » à plusieurs rotors.  En cherchant sur le web, vous trouverez une multitude de sites/blogs qui expliquent comment créer un drone multirotors. Il existe même des systèmes « prêts à l’emploi », et des circuits dédiés au pilotage des différents rotors (qui est une opération relativement complexe). De plus en plus de sites spécialisés vendent tout le matériel nécessaire pour que vous puissiez monter vous même votre drone tri/quadri/hexa/octocopter. Celon les configurations et les matériaux, comptez plusieurs centaines d’euros tout de même.

L’intérêt de ce type de drone est qu’ils peuvent faire du vol stationnaire, ce qui est idéal pour les prises de vues aériennes. Plusieurs entreprises exploitent déjà ce créneau, comme la société Nord Drone Services dont je salue l’initiative 🙂

En revanche, ces drones consomment beaucoup d’énergie rien que pour se maintenir en l’air. Même si certains modèles permettent d’embarquer plusieurs kg de matériel, c’est au détriment de l’autonomie qui dépasse rarement les 20 minutes.

openpilot_logoJ’attire votre attention sur le projet OpenPilot qui propose une plateforme opensource pour la réalisation de ce type de drone. La communauté autour de ce projet est très active et le site est une mine d’information pour quiconque s’intéresse au sujet 🙂

Les drones avions

MQ-1_Predator_UAV_DronePersonnellement, je suis fasciné par les drones utilisés par les militaires depuis quelques années. Ces bijoux de technologies (qui sont en fait de gros avions télécommandés beaucoup plus simple à faire voler qu’un quadricoptère) ont le gros avantage d’avoir des ailes ! S’appuyer sur des ailes pour rester en l’air est beaucoup moins énergivore et permet d’emporter de plus lourdes charges. Il suffit d’assurer une propulsion suffisante pour assurer la portance nécessaire et ainsi maintenir l’avion en vol.

HarfangEn effet, l’objectif du projet Pi BOA Drone, est de parcourir de longues distances, l’autonomie, et par conséquent la gestion de l’energie, est donc une question cruciale. C’est pourquoi je m’oriente plutôt vers un drone avion. En terme de design, j’aime beaucoup les empennages bi-poutre comme pour le drone Harfang d’EADS.

D’où un premier croquis du drone que j’image réaliser :

Pi-BOA-Drone_small

Pi BOA Drone

Qui dit drone, dit moteurs, servos moteurs, capteurs, accéléromètres, gyroscopes, gps,… c’est à dire beaucoup de composants électroniques avec lesquels il va falloir communiquer. Heureusement pour nous, le Raspberry Pi est doté d’un port GPIO (General Purpose Input/Output) 🙂

pi_gpioCet articles servant d’introduction au projet, je ne vais pas détailler ici le fonctionnement de ces pines. Sachez toutefois que le port GPIO du Pi supporte plusieurs types d’interfaces. Pour plus de détails, consulter cette page : http://elinux.org/RPi_Low-level_peripherals

Electronique

Contrairement aux projets Pi TimeLapse, Pi CarJukeBox et Pi HomeDashScreen, nous aurons ici besoins de compétences en électronique. Mes connaissances dans ce domaine sont, pour le moment, très limitées. Pour comprendre comment les choses fonctionnent, je me base sur des livres que j’ai acheté pour l’occasion, ainsi que sur ce que je trouve sur le web.

C’est pourquoi, je lance un appel à l’aide 🙂 Tous ceux qui sont intéressés par le projet et qui ont des compétences en électroniques sont invités à intervenir pour apporter des explications/informations/astuces ou corriger d’éventuelles erreurs 🙂

Aéronautique

Puisqu’il s’agit d’un avion, il va également falloir comprendre les notions de bases de l’aéronautique pour nous permettre de réaliser le corps et les ailes du drone ainsi que son système de propulsion.

Pire que l’électronique, mes connaissances dans ce domaine sont proches du néant 🙁 J’en appelle donc aux passionnés de modélismes et autres professionnels de l’aéronautique et vous encourage à intervenir sur les différents articles 🙂

Démarrage du projet

A l’heure d’aujourd’hui, je n’ai aucune certitude quant à la faisabilité du projet, et je n’ai qu’une vague idée de la manière dont il faut procéder 🙂 Même pour la configuration de l’avion, son design, le nombre de moteurs, ses caractéristiques et sa taille, rien n’est encore fixé, tout est à l’étude 🙂

Ce dont je suis certain, c’est que ce projet sera très instructif et passionnant 🙂

Compte tenu de la quantité de choses à comprendre pour la réalisation d’un drone de ce type piloté par un Pi, je vais aborder les différentes problématiques les unes après les autres. Tout ce qui touchera à l’utilisation du port GPIO, fera l’objet d’un article dédié publié dans la catégorie GPIO du menu principal de ce blog.

Une fois que nous aurons tous les éléments pour contrôler les différents composants, je poursuivrai cet article en expliquant de manière très didactique comment réaliser le drone et le piloter. Comme pour les autres projets, je tâcherai d’établir une liste complète du matériel à acheter ainsi qu’une estimation du prix total. Nous aborderons également les problématiques juridiques liées au pilotage d’un drone sur le territoire français.

A suivre 🙂

Note sur la réglementation relative aux UAV en France

Il est clair que les contraintes administratives et autres règlementations sont ultra restrictives quant au vol des drones et autres UAV en France. Dans tous les cas, je n’ai pas l’intention de faire quelque chose d’illégale, je ferai le nécessaire pour être en règle. S’il savère qu’il est impossible d’obtenir une autorisation pour faire voler mon drone en France, alors je me limiterai à des vols sur propriétés privées, voire dans mon salon si il le faut -_-. Il est certain que je ne vais pas m’arrêter de réfléchir à la conception d’un drone simplement parce que « c’est interdit »… D’ailleurs ce n’est pas « interdit », c’est simplement réglementé ! Il s’agit de se conformer à la réglementation 🙂

Pour le moment, je suis plus concentré sur le challenge technique, je n’en suis pas encore à faire voler quelque chose :)

Par ailleurs, l’idée du projet est bien de faire un drone « home made » et « from scratch ». Ce n’est pas tant de faire voler un drone qui m’intéresse (je pourrais en acheter un…), mais plutôt la partie « ingénierie ». Construire un drone autonome fait appelle à des technos et des compétences très variées, c’est cela qui m’intéresse. C’est comme pour les Légos, une fois que c’est construit, ça n’a plus vraiment d’intérêt ;)

Pour terminer, cela me parait évident de ne pas passer au dessus des zones habitées ni au dessus des aérodromes ^^ Il y a un minimum de bon sens à avoir, et il faut prévoir un itinéraire sans danger. J’ajouterai que dans tous les cas, je ne vais pas lancer mon drone et espérer qu’il arrive à bon port… Je le suivrai de près en voiture avec tout le matériel nécessaire pour le localiser en temps réel :)

Maintenant que ces questions législatives et oh combien barbantes ont été abordées, je vous propose d’en revenir aux problématiques techniques :)

3 – Principe de base

Une page pour les afficher tous

Voici l’arborescence des fichiers nécessaires à l’affichage des différents modules.

  • index.php : page principale qui est appelée par le navigateur
  • ajax.php : contient le code exécuté lors des requêtes AJAX
  • inc.php : contient les fonctions PHP
  • javascript.js : contient les fonctions Javascript
  • style.css : feuille de style

Structure on-ne-peut-plus simple. La page « index.php » est appelée par le navigateur, et une fonction JavaScript se charge d’afficher le contenu de chaque module au bon endroit dans la page et de rafraichir l’affichage à intervalle régulier.

Note : Vous pourrez télécharger tous les fichiers dans une archive dans le dernier article du projet.

index.php

La page d’index se contente de positionner les balises <div> dans lesquelles seront affichés chaque module.

Dans la balise <head>, il y a une balise <meta> dont le but est de rafraichir la page toute les 3600 secondes (soit toutes les heures). Ainsi, toute la page sera rechargée, les compteurs JavaScript réinitialisés, les mise à jour du code sont prises en compte, etc…

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
  <head>
    <title>Jarvis</title>
    <meta http-equiv="Content-Type" content="text/html;charset=utf-8"/>
    <meta http-equiv="Content-Language" content="Fr"/>
    <meta name="Author" lang="fr" content="Torna"/>
    <meta name="Copyright" content="© Torna"/>
    <meta http-equiv="Cache-Control" content="no-cache">
    <meta http-equiv="Pragma" content="no-cache">
    <meta http-equiv="Expires" content="0">
    <meta http-equiv="refresh" content="3600;url=index.php">
    <script type="text/javascript" src="//ajax.googleapis.com/ajax/libs/jquery/1.8.3/jquery.min.js"></script>
    <script type="text/javascript" src="javascript.js"></script>
    <link rel="stylesheet" type="text/css" href="style.css"/>
  </head>
  <body>

    <div id="main">
      <!--div id="etalon">Jarvis <?php //echo date("Y-m-d H:i:s"); ?></div-->
      <div id="horloge"></div>
      <div id="meteo"></div>
      <div id="meteo_black"></div>
      <div id="ts3"></div>
      <div id="ping"></div>
      <div id="analytics"></div>
      <div id="vpn"></div>
      <div id="latency"></div>
      <div id="earth"><img id="img_earth" src="pict/blank.png"></div>
      <div id="moon"><img id="img_moon" src="pict/blank.png"></div>
      <div id="ifstat_oberon_up"><img id="img_oberon_up" src="pict/blank.png"></div>
      <div id="ifstat_oberon_down"><img id="img_oberon_down" src="pict/blank.png"></div>
    </div>

    <?php include('inc.php'); echo analytics(); ?>

  </body>
</html>

Pour les modules qui affichent des images (phases terre et lune, graphique de bande passante), il convient d’insérer une image vide « blank.png » afin d’éviter l’affichage d’une erreur dans la page en attendant que la requète AJAX chargée de l’affichage de l’image soit terminée.

ajax.php

C’est ce fichier qui est appelé par les requètes AJAX et qui est chargé d’appeler la bonne fonction à exécuter.

<?php

  header('Content-type: text/html; charset=utf-8');
  require_once('inc.php');

  if(isset($_REQUEST['block'])){$block = $_REQUEST['block'];}else{$block = 'none';}

  /////////////////////////////////////////////////
  //  LATENCY
  /////////////////////////////////////////////////

  if($block == 'latency'){
    echo latency();
  }

  /////////////////////////////////////////////////
  //  TS3
  /////////////////////////////////////////////////

  else if($block == 'ts3'){
    echo ts3();
  }

  /////////////////////////////////////////////////
  //  METEO
  /////////////////////////////////////////////////

  else if($block == 'meteo'){
    echo meteo();
  }

  /////////////////////////////////////////////////
  //  PING
  /////////////////////////////////////////////////

  else if($block == 'ping'){
    echo ping();
  }

  /////////////////////////////////////////////////
  //  VPN PPTPD
  /////////////////////////////////////////////////

  else if($block == 'vpn'){
    echo vpn();
  }

  /////////////////////////////////////////////////
  //  IFSTAT
  /////////////////////////////////////////////////

  else if($block == 'ifstat'){
    imagickHisto ($_REQUEST['max'], $_REQUEST['eth'], $_REQUEST['up_down']);
  }

?>

Un bloc de code pour chaque module. En fonction de la variable $block passée en paramètre de la requète AJAX, on appelle la fonction ciblée.

inc.php

Ce fichier contient les fonctions appelées par le fichier ajax.php. Même principe, un bloc de code pour chaque module.

En gros, une fonction par module 🙂 Le détail de chaque fonction fera l’objet d’un article à suivre.

javascript.js

Ce fichier contient les fonctions JavaScript qui vont lancer les requêtes AJAX à intervalle réuglier.

/* initialisation des fonctions de tous les modules au chargement de la page */
$(document).ready(function() {
   fonction_nom_du_module_1 ();
   fonction_nom_du_module_2 ();
   ...
});

/* initialisation des variables timeout pour chaque module */
var timeout_nom_du_module_1; 
var timeout_nom_du_module_2;
...

/* définition de la fonction pour le module nom_du_module_1 */

function nom_du_module_1 ()
{
  $.ajax({
    async : false,
    type: "GET",
    url: "./ajax.php",
    data: "block=nom_du_module_1",
    success: function(html){
      $("#nom_du_module_1").html(html);
    }
  });

  g = setTimeout("nom_du_module_1()", 10000);
}

Je ne mets ici que la structure gobale du fichier pour expliquer le principe. Le fichier complet sera disponible au téléchargement dans le dernier article.

style.css

Ce fichier contient la feuille de style de la page, c’est elle qui contient toutes les options de mise en forme des éléments de la page (position, taille, couleurs, etc…).

/* init */

body
{
  background-color  : rgba(0, 0, 50, 1);
  font-family       : Verdana, "Courier New", "Lucida Console";
  font-size         : 14px;
  font-weight       : normal;
  padding           : 0px;
  margin            : 0px;
  overflow          : hidden;
}

div, table, tr, td, th, h1, h2, h3, a, span, p, pre, fieldset, input, textarea, form, img, select
{
  font-family       : Verdana, "Courier New", "Lucida Console";
  font-size         : 14px;
  font-weight       : normal;
  padding           : 0px;
  margin            : 0px;
  color             : #FFF;
}

/* main */

div#main
{
  width             : 1366px;
  height            : 768px;
  position          : relative;
  overflow          : hidden;
  background-color  : rgba(0, 0, 0, 1);
  color             : #FFF;
}

La div qui a pour id main est la div qui contient toutes les autres div de chaque module. Ici, je fixe sa taille en pixel à la résolution native de mon écran 1366×768 px.

La couleur de fond (background-color) est fixée au noir mais vous pouvez choisir ce qui vous plaît 🙂