Dirigeable publicitaire : Différence entre versions

Version du 2 mai 2016 à 17:45

Présentation générale du projet

Le but est d'avoir un dirigeable de dimension réduite capable d'évoluer de façon autonome dans le hall de l'école.

Cahier des charges

Objectifs et description du projet

Le but du projet est de créer un dirigeable publicitaire (structure et logiciel) capable de voguer en autonomie. Celui-ci doit éviter les obstacles présents sur sa route.

Nous devrons donc d'abord réaliser la structure tout en prenant en compte le poids maximal que pourra supporter le dirigeable. Dans le même temps, nous devrons concevoir la partie logicielle qui devra assurer le vol du dirigeable.

Choix techniques : matériel et logiciel

Nous aurons besoin de :

• Un ARDUINO ou Raspberry Pi afin de contrôler le dirigeable.
• Une enveloppe imperméable à l'hélium pouvant en contenir.
• Un matériau léger pour la structure du dirigeable (fil de fer, aluminium ...).
• Environ 1m3 d'hélium pour permettre au dirigeable de voler.
• Des hélices pour faire avancer le dirigeable (probablement fabriquées à l'aide d'une imprimante 3D). Celles-ci seront soit orientables, soit jumelées avec un gouvernail.
• Capteurs d'altitude et de proximité (afin d'éviter les chocs).
• Une publicité à afficher sur le dirigeable.
• Une batterie pour alimenter l'(es) hélice(s).

Liste de matériel

Échanges concernant le projet

Avant le commencement

• 12/11/2015 Suite à un échange par mail, nous avons obtenu les réponses suivantes :
  • Le dirigeable pourra contenir jusqu'à 2 bouteilles d'hélium vendues dans le commerce.
  • Mr Redon nous a dit qu'il essayait de récupérer une enveloppe d'un ballon sonde météo, pour éviter d'acheter une enveloppe onéreuse dans le commerce.
  • Réaliser les hélices depuis une imprimante 3D semble être une bonne idée.
• 02/12/2015 Un deuxième échange par mail, nous avons pu affiner notre CDC :
  • L'idée de plusieurs hélices permettant de se diriger dans 3 dimensions paraît plus judicieuse
  • Seule l'enveloppe de ballon pourrait suffire à la conception du dirigeable (sans 'structure' métallique)
  • L'autonomie de notre dirigeable devra être de quelques heures
• 08/12/2015 Troisième échange en direct, nous avons plus de précisions quant au CDC ainsi qu'aux méthodes que nous allons employer :
  • Notre tuteur, Xavier Redon devrait pouvoir se procurer 1 (ou plusieurs) enveloppes de ballon sonde météo ce qui constituerait l'enveloppe de notre dirigeable
  • Nous avons réfléchi ensemble et opterons pour une nacelle fixée sous l'enveloppe où toute la partie arduino/moteur se situera
  • Nous pourrions, si tout se passe bien, récupérer 3 moteurs ainsi que 3 hélices provenant d'un drone ne fonctionnant plus -> Cela nous évite de les imprimer via l'imprimante 3D
  • L'Arduino sera notre outil clé et non la Raspberry, car ses capacités sont suffisantes à priori pour nos besoins
  • L'idée du gouvernail semble compliquée à mettre en place, c'est pourquoi nous choisirons les 3 hélices (pour la position latérale mais surtout le contrôle de l'altitude)
  • Nous avons pensé également à une multitude de capteurs (ultrasons) afin de capter les obstacles pour ensuite les éviter (sous la nacelle et sur le pourtour de l'enveloppe)
  • Pour finir, notre premier objectif sera de réaliser la nacelle (imprimante 3D, récupération de matériel, ...) qui pourra permettre d’accueillir la totalité de nos composants/carte(s)

Calendrier prévisionnel

Avancement du Projet

Explication des choix

• A la base, nous devions utiliser les moteurs d'un ARDrone défectueux afin de déplacer le dirigeable.

Une fois ces moteurs récupérés, nous avons effectué des tests en tension et courant pour comprendre leur fonctionnement. Cependant, les moteurs ne sont pas faciles d'accès sans le kit adéquat.

• De plus, nous avons également essayé de les démarrer depuis l'Arduino en communication série. le problème était que les 2 fils (RX/TX) des moteurs sont regroupé en un seul fil alors que l'Arduino possède 2 pins différents pour TX/RX.

Avec l'aide de Mr Redon, nous avons réussi à communiquer entre 2 Arduinos via 'un seul fil' par un montage simple (avec résistances). Cependant, lorsque nous avons testé de communiquer de l'Arduino au moteur avec ce câblage, aucun test ne s'est avéré concluant. De plus, la méthode de contrôle via ventilateurs nous a parue plus simple et aussi efficace.

• Le test que nous avons effectué était le suivant:

    Le fil rouge du moteur sur le + de notre batterie 12V
    Le fil noir reliée à la masse de l'arduino et celle de la batterie
    Le fil blanc relié au +5V de l'arduino
    Le fil orange en série avec les fils RX/TX de l'arduino.

La LED du moteur s'allume (mais reste rouge). Cependant, l'envoi d'un octet de l'arduino vers le moteur se fait, en revanche le getserial() ne se finit pas.

Montage de l'arduino en série avec le moteur

Le code correspondant est le suivant:

/* Code de ping.c qui gère réception et envoi d'octets */
#include <avr/io.h>
#include <util/delay.h>
#include <stdio.h>

#include "serial.h"

int main(void)
{
DDRB=0x3f;
unsigned char test=2;
unsigned char ball;
unsigned char recu=0x20;

init_serial(115200);

#ifdef PING
ball=0xE0;    //Valeur de l'octet à envoyer au moteur;
send_serial(ball);
#endif
while(recu==0x20){
PORTB=0x30&0x3f;
 recu=get_serial();
_delay_ms(100);
PORTB=test&0x3f;

  } 

return 0;
}

/* Code de serial.c avec toutes les fonctions correspondant à la communication série */
#include <avr/io.h>
#include <stdio.h>

#include "serial.h"

static int send_serial_printf(char c,FILE *stream);
static FILE mystdout=FDEV_SETUP_STREAM(send_serial_printf,NULL,_FDEV_SETUP_WRITE);

void init_serial(long int speed){
/* Set baud rate */
UBRR0 = F_CPU/(((unsigned long int)speed)<<4)-1;

/* Enable only receiver */
UCSR0B = (1<<RXEN0);

/* Do not let TX as output be be able to receive */
DDRD &= ~0x02;

/* Set 8 bits character and 1 stop bit */
UCSR0C = (1<<UCSZ01 | 1<<UCSZ00);

/* Set off UART baud doubler */
UCSR0A &= ~(1 << U2X0);
}

void send_serial(char c){
UCSR0B &= ~(1<<RXEN0);
UCSR0B |= (1<<TXEN0);
DDRD |= 0x02;
UDR0 = c;
loop_until_bit_is_set(UCSR0A, TXC0);
UCSR0A |= (1<<TXC0);
DDRD &= ~0x02;
UCSR0B &= ~(1<<TXEN0);
UCSR0B |= (1<<RXEN0);
}

char get_serial(void){
loop_until_bit_is_set(UCSR0A, RXC0);
return UDR0;
}

void init_printf(void){
init_serial(9600);
stdout=&mystdout;
}

static int send_serial_printf(char c,FILE *stream){
if(c=='\n') send_serial('\r');
send_serial(c);
return 0;
}

C'est pour cela que nous avons décidé d'abandonner la méthode avec les moteurs ARDrone pour consacrer la totalité de notre temps à la solution incluant les ventilateurs. Nous sommes à ce jour en attente de l'hélium afin de réaliser nos tests.

Semaine 1

• Contact avec la société vendeuse d'hélium : attente d'un devis.

Semaine 2

• 2nd contact avec la société : la demande de devis est transmise au commercial d'Air Liquide.
• Nous avons pour projet de faire les plans de câblage Arduino sur le logiciel Fritzing.
• Recherche d'une nouvelle enveloppe pour le ballon.
• Prise de contact avec Mr Jean SECQ pour gonfler le ballon.
• Gonflage du ballon avec de l'air afin de prendre des mesures préalables et de vérifier son imperméabilité à l'air premièrement
• Mesure du ballon gonflé -> 186cm du sommet du ballon à l'embouchure (Afin de vérifier s'il se dégonfle ou pas et de dimensionner la nacelle)

Ballon original, gonflé à l'air

• Au lendemain de la prise de la photo, la taille du ballon était réduite de moitié --> nous allons devoir trouver une enveloppe de ballon.
• Nous cherchons également toujours une batterie légère fournissant environ 11V en sortie et 2000mAh afin d'avoir une bonne autonomie
• Nous devons trouver les références des connecteurs sur la carte mère du drone HS afin de pouvoir réaliser des tests sur les moteurs

Devis pour l'hélium

Nous avons reçu un devis pour l'hélium :

Monsieur DELECROIX,

Suite à notre conversation :


I6020L50R2A001 HELIUM U Grande Bouteille L50 79,80€
Détendeur HEPAL 12 : REF 153608 - Prix HT :307,97 € HT - Remise à déduire FAC et ECOLES : 20% - Frais de port 27,50 €
Délai : 1 semaine

Nous n'avons pas besoin du détendeur (monsieur Jean SECQ pourra nous en procurer un), et la contenance de la bouteille d'hélium est de 9m3, ce qui est amplement suffisant pour nous.

Semaine 3

• Nous avons reçu le ballon, que nous venons de gonfler :

Ballon final, gonflé à l'air

• De même, nous avons pu tester un des capteurs ultrasons HC-SR04 fourni par monsieur Redon. Nous l'avons câblé à l'Arduino de la façon suivante :

Câblage du capteur ultrason HC-SR04

• Le code correspondant pour tester le capteur est :

/* Utilisation du capteur Ultrason HC-SR04 */

// définition des broches utilisées
int trig = 12;
int echo = 11;
long lecture_echo;
long cm;

void setup()
{
  pinMode(trig, OUTPUT);
  digitalWrite(trig, LOW);
  pinMode(echo, INPUT);
  Serial.begin(9600);
}

void loop()
{
  digitalWrite(trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig, LOW);
  lecture_echo = pulseIn(echo, HIGH);
  cm = lecture_echo / 58;
  Serial.print("Distancem : ");
  Serial.println(cm);
  delay(1000);
}

• Nous obtenons les résultats suivants :

Distancem : 26
Distancem : 12
Distancem : 9
Distancem : 10
Distancem : 9
Distancem : 2
Distancem : 5
Distancem : 26
Distancem : 24
Distancem : 24
Distancem : 24
Distancem : 12
Distancem : 11

Ces résultats sont conformes aux distances mesurées.

• Nous avons également simulé le comportement des moteurs à l'aide de diodes. Lorsque la distance mesurée est supérieure à 50cm, la LED verte s'allume, sinon, c'est la rouge qui s'allume. Les moteurs se comporteront de manière analogue, avec des distances différentes.

Media:Simulation_diode.mp4

Semaine 4

• Suite à la demande des enseignants, nous avons passé la plupart de notre temps de projet hebdomadaire à créer notre librairie de composants sous Altium (en attendant vérification de M. Alexandre Boé).

Schematic HCSR04

Footprint HCSR04

Schematic USB

Footprint USB

• Nous avons également pu vérifier que le ballon est toujours gonflé (à l'air) au bout d'environ 2 semaines, il nous restera donc à tester son imperméabilité à l'hélium.

Semaine 5

• Nous avons réalisé le plan d'une boîte représentant la nacelle sur Inkscape.
• Nous avons pu faire cette nacelle grâce à la découpeuse laser du Fabricarium. Nous avons prévu les trous afin de laisser passer les ficelles pour la maintenir au ballon. D'autres trous sont présents pour laisser sortir les moteurs (un en dessous pour haut/bas) les 2 autres derrière la nacelle écartés de 90° (pour devant/derrière gauche/droite).

Prototype de la nacelle

• Nous avons réussi à démonter tout le drone puis nous avons reconstitué l'électronique d'un moteur avec des câbles soudés entre eux afin de pouvoir visualiser la tension, le courant ainsi que les données envoyées à un moteur isolé.

Semaine 6

• Nous avons essayé de se pencher sur le fonctionnement des moteurs de l'AR Drone, vu le temps restant pour l'avancement du projet, nous optons pour une des deux solutions alternatives suivantes:

- Essayer de diriger la nacelle grâce à des ventilateurs récupérés
- Utiliser des moteurs simple de commande couplés aux hélices de l'AR Drone

• Nous avons également réussi à faire fonctionner le ventilateur avec la batterie du drone en commandant la marche et l'arrêt depuis l'Arduino avec un transistor.

Schéma avec ventilateur ou moteur

Semaine 7

• Nous avons effectué un test avec le ventilateur le plus puissant à disposition, fixé à la nacelle elle-même attachée avec de la ficelle en hauteur. Le test s'est avéré peu concluant, en effet le ventilateur ne permettait pas un déplacement de la nacelle assez important afin de pouvoir contrôler celle-ci en cas de présence d'obstacle.

•  Nous essayons maintenant donc de communiquer avec le moteur de l'AR Drone, cependant celui-ci ne dispose que d'un fil de données (Reception/Emission). Nous essayons donc tout d'abord de communiquer entre 2 Arduinos en reliant tous les TX et RX sur un même ligne de breadboard.

Si nous réussissons cela, nous pourrons donc appliquer cette méthode sur le moteur afin de pouvoir lui envoyer le message de mise sous tension.

Semaine 8

• Nous avons encore essayé en début de semaine de faire fonctionner le moteur de l'AR Drone mais sans succés.

• Nous avons réussi à commander un moteur ainsi qu'un ventilateur par le biais d'un relais. Nous avons testé un programme qui déclenche celui-ci lorsque la distance de l'obstacle est inférieure à une distance fixée au préalable.

Nous allons donc créer un shield pour l'Arduino Mega afin de recréer les 3 circuits de gestion des 3 moteurs (ou ventilateurs) proprement, ainsi que regrouper les GND et les +VCC des 6 capteurs ultrasons.

Semaine 9

• Suite à un mail de monsieur Boé, nous avons essayé de commander les moteurs à l'aide d'un transistor MOSFET. Le principe est le même que pour le relais, mais le montage est plus simple, et surtout plus léger. Après plusieurs recherches, nous avons donc réalisé le montage suivant :

Schéma de contrôle avec MOSFET

Ce montage fonctionne parfaitement, et nous permet donc de contrôler la vitesse de rotation du ventilateur.

• Nous sommes allés au magasin Sélectronic de Ronchin pour nous procurer des transistors MOSFET IRF540N. Il n'y en avait pas de disponible à Polytech'Lille.

• En attendant de pouvoir effectuer des tests grandeur nature avec l'hélium et 3 ventilateurs, nous avons réaliser le montage sur une breadboard avant de créer le shield pour s'assurer du bon fonctionnement. Nous avons donc placé 3 capteurs ultrasons, chaque capteur pouvant déclencher la marche ou l'arrêt d'un des 3 ventilateurs. En effet, les ventilateurs tournent lorsque la distance du capteur approprié est inférieure à 50 cm. Le montage sur breadboard est lourd mais il fonctionne, nous allons donc pouvoir réaliser le shield.

Montage avec 3 capteurs 3 ventilateurs

Le code approprié:

// définition des broches utilisées pour chacun des 3 ventilateurs

int echo1 = 2; 
int trig1 = 3;


int echo2 = 4;
int trig2 = 5;


int echo3 = 6;
int trig3 = 7;

// 3 mesures (1/ventilateur) seront effectuées
long lecture_echo1;
long lecture_echo2;
long lecture_echo3;

long cm1;
long cm2;
long cm3;

// déclaration des 3 pins permettant le contrôle des marche/arrêt de chaque ventilateur
int cont1 = 8;
int cont2 = 9;
int cont3 = 10;


void setup()
{
  pinMode(trig1, OUTPUT);
  digitalWrite(trig1, LOW);
  pinMode(trig2, OUTPUT);
  digitalWrite(trig2, LOW);
  pinMode(trig3, OUTPUT);
  digitalWrite(trig3, LOW);
  pinMode(echo1, INPUT);
  pinMode(echo2, INPUT);
  pinMode(echo3, INPUT);
  pinMode (cont1, OUTPUT);
  pinMode (cont2, OUTPUT);
  pinMode (cont3, OUTPUT);
  Serial.begin(9600);
  
}

void loop()
{
// mesure de la distance du capteur1 (relié au ventilateur 1) en cm
  digitalWrite(trig1, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig1, LOW);
  lecture_echo1 = pulseIn(echo1, HIGH);
  cm1 = lecture_echo1 / 58;
  Serial.print("Distance1 m : ");
  Serial.println(cm1);
// mise en route du ventilateur si la distance mesurée est inférieure à 50cm
  if (cm1<50){
      digitalWrite (cont1, HIGH);
  }
  else {
    digitalWrite (cont1, LOW);
   }

  digitalWrite(trig2, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig2, LOW);
  lecture_echo2 = pulseIn(echo2, HIGH);
  cm2 = lecture_echo2 / 58;
  Serial.print("Distance2 m : ");
  Serial.println(cm2);
  if (cm2<50){
      digitalWrite (cont2, HIGH);
  }
  else {
    digitalWrite (cont2, LOW);
   }

  digitalWrite(trig3, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig3, LOW);
  lecture_echo3 = pulseIn(echo3, HIGH);
  cm3 = lecture_echo3 / 58;
  Serial.print("Distance3 m : ");
  Serial.println(cm3);
  if (cm3<50){
      digitalWrite (cont3, HIGH);
  }
  else {
    digitalWrite (cont3, LOW);
   }
 
  delay(500);
}

Semaine 10

• En début de semaine nous sommes allés chercher des ventilateurs assez puissants afin de pouvoir faire nos tests une fois l'hélium arrivé. Ceci étant, il nous manque toujours quelques ventilateurs afin de pouvoir gérer toutes les directions voulues. Nous allons donc devoir nous procurer les ventilateurs restants.

• Le mercredi, nous avons fait les plans de notre deuxième nacelle, plus grande afin qu'elle puisse comporter l'Arduino, la batterie, ainsi que la breadboard et que les câblages soient plus aisés. Pour le moment, nous voulons essayer la méthode des ventilateurs couplés aux transistors sans Shield, afin de vérifier que cette méthode fonctionne.

Nous avons également pensé à la répartition des 3 constituants de la nacelle, en effet, nous voulons équilibrer le poids afin que cette dernière soit stable. Nous allons donc centrer la batterie (élément le plus lourd dans la nacelle). Nous avons prévu 2 trous par face afin de pouvoir relier la nacelle au ballon (contre 1 seul trou par face lors du dernier prototype ce qui rendait la nacelle un peu instable).

• Lorsque nous aurons tous les ventilateurs nécessaires au bon fonctionnement, ainsi que l'hélium, nous pourrons tester notre méthode (avec câblages), et si celle-ci se montre viable, nous réaliserons un shield afin de rendre plus propre la nacelle.

• Pour le moment, nous fixerons directement les ventilateurs aux parois, si l'appel d'air n'est pas assez conséquent, nous percerons alors des trous sur chaque face afin de pouvoir fixer des tiges qui permettront d'éloigner les ventilateurs de la nacelle, ce qui augmenterait les poussées du dirigeable.

• Pendant le week-end nous avons acheté des vis, des boulons des rondelles ainsi qu'un tube en aluminium afin de pouvoir écarter les ventilateurs de la nacelle. Nous avons donc découpé des morceaux de tubes d'alu de 1,5cm qui serviront d'entretoise. La vis partira du ventilateur passera dans l'entretoise, et sera fixée à l'intérieur de la nacelle par le boulon précédé de la rondelle. La photo suivante illustre un des 4 coins du ventilateurs fixé à la nacelle, ceci sera reproduit pour tous les ventilateurs nécessaires.

Nous avons choisi l'entretoise en aluminium afin de minimiser le poids à soulever.

Montage ventilateur/nacelle

Semaine 11

• Nous avons pu en début de semaine gonfler le ballon à l'hélium. Nous avons suivi les recommandations du revendeur, et avons gonflé le ballon au maximum: Diamètre de 1m20 soit un volume d'environ 0.9m³. Le ballon était indiqué comme pouvant soulever jusqu'à 770g. Nous avons suspendu des masses en dessous du ballon, celui ci nous a montré qu'il pouvait soulevait jusqu'à 450g. (Et non 570g en enlevant le poids de l'enveloppe comme indiqué sur le site du revendeur). Nous avons donc pesé les constituants de la nacelle ainsi que l'enveloppe du ballon:

   Enveloppe: 200g
   1 ventilateur: 140g
   Ensemble vis/rondelles/entretoises/boulons (pour 4 ventilateurs): 75g
   Nacelle: 135g
   Arduino: 34g
   Batterie: 108g
   1 capteur ultrason: 8g

Ceci nous montre donc que la solution avec 3 ventilateurs est impossible, le poids est largement trop excessif. Nous sommes donc en train de réessayer la solution avec les moteurs de l'ARDrone afin de rentrer dans le poids maximal possible.

Semaine 12

• Nous avons essayé ce lundi d'attacher un de ventilateur en dessous de la nacelle (et centré) grace à une équerre en aluminium. Le test s'est avéré concluant: En lestant la nacelle au poids d'équilibre, celle-ci reste à altitude constante et le ventilateur permet de faire avancer le ballon en ligne droite.

• Le test a été pris en vidéo

Media:Video1.mp4

• Nous avons remarqué qu'afin de porter 2 ventilateurs, nous dépassions que de très peu le poids maximum possible à soulever. Nous allons donc réaliser un second test qui consisterait en 2 ventilateurs, 1 pour chaque direction, ainsi nous pourrions faire aller-retour du ballon avec des capteurs ultrasons pour détecter la fin de parcours (1 dans chaque direction). Pour pouvoir gagner en poids soulevé, nous avons acheté des planches de Balza afin de refaire une nacelle plus légère ce qui compenserait l’excédent de poids soulevé.

Fichiers Rendus