ENIB 2025 : E-BOO

Titre de la fiche expérience :

description (résumé)

Le projet E-BOO est un projet de construction d'une tourelle automatique. Celui-ci Consiste en une tourelle pouvant trouver une cible proche et lui tirer un élastique dessus. Il est composé de la liste du matériel juste en dessous.

Le principe est le suivant : La tourelle peut tourner et avec un capteur trouver une cible proche puis lui tirer dessus grâce à un système de tir d'élastique déclenché automatiquement. Cette tourelle sera faite pour rappeler le Hiboux avec deux LED pour ses yeux, celles-ci s'allument différemment en fonction du mouvement effectué

Introduction

éventuelle vidéo

Nous sommes 3 énibiens étudiant en 1ère année du cycle ingénieur (3ème année avec le cycle préparatoire) et nous nous appelons JANNIN Brewen, ROHOU Logan et PAYRASTRE Mathis.

Ce projet E-BOO a été réalisé dans le cadre de l'intersemestre 3 et lors du hackathon le 22 et 23 janvier 2025 avec l'aide de l'association des Petits Débrouillards : [[1]] et Les Fabriques Du Ponants [[2]].

Cette présentation en plusieurs parties vous montrera comment ce projet a été réalisé, avec quels moyens et surtout l'aventure que nous avons faite durant ces deux jours.

outil et matériel

nombre	élément
3	Servo-moteur
1	Capteur Ultra-son
2	LED
1	Carte Arduino esp8266
*	Carton
*	câble
*	colle
*	clou

fichiers à joindre

code, ficher d'impression 3D, de découpe laser ou vinyle, ...

test des éléments

Au tout début, le code ressemblait à celui ci-dessous, Ce sont des test pour vérifier le bon fonctionnement des éléments et aussi pour s'approprier les commandes afin de mieux les utiliser après. (Le dessin est celui du microcontrôleur utilisé dans la construction du code avec le numéro des broches)

 1  
 2 
 3 /*
 4                                /     D1 mini     \
 5                               |[ ]RST        TX[ ]|
 6                               |[ ]A0  -GPIO  RX[ ]|
 7                               |[ ]D0-16    5-D1[ ]| SCL
 8                               |[ ]D5-14    4-D2[ ]| SDA
 9                               |[ ]D6-12    0-D3[ ]|
10                               |[ ]D7-13    2-D4[ ]| LED_BUILTIN
11                               |[ ]D8-15     GND[ ]|
12                               |[ ]3V3 .      5V[ ]|
13                               |       +---+       |
14                               |_______|USB|_______|
15                               */
16 //Ajout de la bibliothèque ultrasonic
17 #include <Ultrasonic.h>
18 #include <Servo.h>
19 
20 
21 //Création de l'objet ultrasonic
22 Ultrasonic ultrasonic(5, 4);
23 Servo serv_mot_1;
24 Servo serv_mot_2;
25 Servo serv_mot_3;
26 const int LED_L = 2;
27 const int LED_R = 15;
28 
29 
30 
31 void setup() {
32 
33   Serial.begin(9600); // démarrage de la connexion série*
34   pinMode(LED_L,OUTPUT);
35   pinMode(LED_R,OUTPUT);
36   serv_mot_1.attach(16,544,2600);
37   serv_mot_2.attach(14,544,2600);
38   serv_mot_3.attach(13,544,2600);
39 
40 }
41 
42 
43 void loop() {
44 
45   //utilisation de l'objet
46 
47   int distance = ultrasonic.read();
48 
49   // affichage de la distance dans le terminal série
50 
51   Serial.print("Distance in CM: ");
52 
53   Serial.println(distance);
54 
55   delay(1000); //délais d'une seconde
56   if(distance <10){
57     digitalWrite(LED_L,HIGH);
58     digitalWrite(LED_R,HIGH);
59     serv_mot_1.write(45);
60     serv_mot_2.write(0);
61     serv_mot_3.write(0);
62   }
63   else if(distance <20){
64     digitalWrite(LED_L,LOW);
65     digitalWrite(LED_R,HIGH);
66     serv_mot_1.write(0);
67     serv_mot_2.write(45);
68     serv_mot_3.write(0);
69 
70   }
71   else{
72     digitalWrite(LED_L,LOW);
73     digitalWrite(LED_R,LOW);
74     serv_mot_1.write(0);
75     serv_mot_2.write(0);
76     serv_mot_3.write(45);
77   }
78    }

Première version

Cette version a pour but d'avoir un système de base permettant de faire la suite d'action de, tourner, s'arrêter, pencher la tête, tirer, remettre la tête droite, tourner.

 1 #include <Ultrasonic.h>
 2 #include <Servo.h>
 3 
 4 
 5 //Création de l'objet ultrasonic
 6 Ultrasonic ultrasonic(5, 4);
 7 Servo serv_mot_1;
 8 Servo serv_mot_2;
 9 Servo serv_mot_3;
10 const int LED_L = 2;
11 const int LED_R = 15;
12 float angle_1 = 0;
13 float angle_2 = 0;
14 float angle_3 =0;
15 float next_angle_add = 1;
16 int something = 0;
17 
18 
19 
20 void setup() {
21 
22   Serial.begin(9600); // démarrage de la connexion série*
23   pinMode(LED_L,OUTPUT);
24   pinMode(LED_R,OUTPUT);
25   serv_mot_1.attach(16,544,2600);
26   serv_mot_2.attach(14,544,2600);
27   serv_mot_3.attach(13,544,2600);
28   angle_1 = serv_mot_1.read();
29   angle_2 = serv_mot_2.read();
30   angle_3 = serv_mot_3.read();
31 
32 }
33 
34 
35 void loop() {
36 
37   //utilisation de l'objet
38 
39   int distance = ultrasonic.read();
40 
41   // affichage de la distance dans le terminal série
42 
43   Serial.print("Distance in CM: ");
44   Serial.println(distance);
45   delay(100); //délais 
46 
47   if (angle_1 ==0){
48     next_angle_add = 1;
49   }
50   else if(angle_1 ==180){
51     next_angle_add = -1;
52   }
53   angle_1 = angle_1 + next_angle_add;
54   serv_mot_1.write(angle_1);
55   
56 
57   if(distance <10){
58     digitalWrite(LED_L,HIGH);
59     digitalWrite(LED_R,HIGH);
60     next_angle_add =0;
61     serv_mot_2.write(45);
62     delay(1000);
63     serv_mot_3.write(145);
64     delay(1000);
65     serv_mot_2.write(90);
66     delay(1000);
67     serv_mot_3.write(45);
68     delay(1000);
69     next_angle_add =1;
70   }
71   else if(distance <20){
72     digitalWrite(LED_L,LOW);
73     digitalWrite(LED_R,HIGH);
74 
75   }
76   else{
77     digitalWrite(LED_L,LOW);
78     digitalWrite(LED_R,LOW);
79   }
80    }

Code finalisé

Ici on retrouve donc le code en entier qui ressemble énormément a la première version qui était déjà assez bien pour ce que l'on voulais. Ce qui change ici c'est la possibilité de modifié simplement les paramètres et d'avoir différents angles de tir et des LED qui s'allument différemment en fonction de la distance

  1 //Ajout de la bibliothèque ultrasonic
  2 #include <Ultrasonic.h>
  3 #include <Servo.h>
  4 
  5 
  6 //Création de l'objet ultrasonic
  7 Ultrasonic ultrasonic(5, 4);
  8 Servo serv_mot_1;
  9 Servo serv_mot_2;
 10 Servo serv_mot_3;
 11 const int LED_L = 2;
 12 const int LED_R = 15;
 13 float angle_1 = 0;
 14 float angle_2 = 90;
 15 float angle_3_first =45;
 16 float angle_3_end = 145;
 17 float next_angle_add = 1;
 18 int something = 0;
 19 float angle_tilt = 45;
 20 int delay_shoot = 1000;
 21 
 22 
 23 
 24 void setup() {
 25 
 26   Serial.begin(9600); // démarrage de la connexion série*
 27   pinMode(LED_L,OUTPUT);
 28   pinMode(LED_R,OUTPUT);
 29   serv_mot_1.attach(16,544,2600);
 30   serv_mot_2.attach(14,544,2600);
 31   serv_mot_3.attach(13,544,2600);
 32   angle_1 = serv_mot_1.read();
 33   //angle_2 = serv_mot_2.read();
 34   //angle_3 = serv_mot_3.read();
 35 
 36 }
 37 
 38 
 39 void loop() {
 40 
 41   //utilisation de l'objet
 42 
 43   int distance = ultrasonic.read();
 44 
 45   // affichage de la distance dans le terminal série
 46 
 47   Serial.print("Distance in CM: ");
 48   Serial.println(distance);
 49   delay(50); //délais 
 50 
 51   if (angle_1 ==0){
 52     next_angle_add = 1;
 53   }
 54   else if(angle_1 ==180){
 55     next_angle_add = -1;
 56   }
 57   angle_1 = angle_1 + next_angle_add;
 58   serv_mot_1.write(angle_1);
 59   
 60 
 61   if(distance <10){
 62     digitalWrite(LED_L,HIGH);
 63     digitalWrite(LED_R,HIGH);
 64     next_angle_add =0;
 65     serv_mot_2.write(angle_tilt/(distance/10));
 66     delay(delay_shoot);
 67     serv_mot_3.write(angle_3_end);
 68     delay(delay_shoot);
 69     serv_mot_2.write(angle_2);
 70     delay(delay_shoot);
 71     serv_mot_3.write(angle_3_first);
 72     delay(delay_shoot);
 73     next_angle_add =1;
 74   }
 75   else if(distance <50){
 76     digitalWrite(LED_L,LOW);
 77     digitalWrite(LED_R,HIGH);
 78     next_angle_add =0;
 79     serv_mot_2.write(angle_tilt/(distance/10));
 80     delay(delay_shoot);
 81     serv_mot_3.write(angle_3_end);
 82     delay(delay_shoot);
 83     serv_mot_2.write(angle_2);
 84     delay(delay_shoot);
 85     serv_mot_3.write(angle_3_first);
 86     delay(delay_shoot);
 87     next_angle_add =1;
 88 
 89   }
 90   else if(distance <=100){
 91     digitalWrite(LED_L,LOW);
 92     digitalWrite(LED_R,HIGH);
 93     next_angle_add =0;
 94     serv_mot_2.write(angle_tilt/(distance/10));
 95     delay(delay_shoot);
 96     serv_mot_3.write(angle_3_end);
 97     delay(delay_shoot);
 98     serv_mot_2.write(angle_2);
 99     delay(delay_shoot);
100     serv_mot_3.write(angle_3_first);
101     delay(delay_shoot);
102     next_angle_add =1;
103 
104   }
105   else{
106     digitalWrite(LED_L,LOW);
107     digitalWrite(LED_R,LOW);
108   }
109    }

étapes de fabrication

indiquer autant d'étape que nécessaire, chacune illustrée par des images (photo, dessins, ...)

Les idées

Pour démarrer ce projet il fallait une idée, une idée qui utilisait le matériel du 'Paper Boy'.

Le débat sur ces idées aura durée une heure environ, différentes ont vu le jour comme une mine à confettis, une tortue sur un skateboard ou encore une voiture mais aucune n'avait vraiment retenu notre attention.

Puis en réfléchissant nous avons trouvé une idée qui nous convenait : Une Tourelle

Les plans

Plusieurs idée sont venu mais le principe reste le même, un socle pour la tenir en place, un pied pour pouvoir tourner et balayer le paysage et une tête

Le design final retenu sera d'essayer de se rapprocher d'un Hiboux, d'où le nom de cette tourelle E-BOO

rélisation des pièce gérant la mecanique

Construction

Une maquette a été faite pour qu'on puisse comprendre ce qu'il fallait faire, on a regardé où placer les servomoteur ainsi que le capteur à ultrason et il ne resterai donc plus que à la construire.

Nous avons donc réalisé des plan 3D de pièces importantes pour le bon fonctionnement de la tourelle sur CATIA et les avons fait imprimer sur les imprimantes 3D dans les locos.

Code et Branchements électronique

Le code est fait pour que la tourelle tourne sur elle même en continue jusqu'à ce qu'elle rencontre un obstacle dans son champ de vision, celle-ci s'arrêtera va pencher sa tête et tirer un élastique sur la cible.

En fonction de la distance entre la tourelle et sa cible, les LED s'allument de manière différentes pour montrer que l'obstacle a ben été détecté. Le code est affiché au dessus mais son fonctionnement reste très simple.

Pour les branchements, la carte arduino est sur une petite plaque électronique et ses entrées seront dupliquées sur une autre afin de faciliter le branchement, ensuite les pins assignés seront branchés aux éléments correspondant (cf:code ci-dessu)

Troubleshouting

Pendant ces deux jours nous avons rencontré beaucoup de problèmes sur le matériel .

Malheureusement la capteur à ultrason ne fonctionnais pas au début nous en avons donc changé, pareil pour la carte Arduino nous avons dû en changer deux fois avant d'enfin pouvoir faire fonctionner le programme qui lui aussi comportait beaucoup de problèmes. Le code à faire était très simple grâce aux aides du wiki mais très difficile à mettre en place à cause de bugs divers de la connexions entre le pc et la carte arduino, mais un petit redémarrage nous a arrangé le coup.

Pour la partie mécanique de la tourelle, la difficulté était de trouver un système de tir fonctionnel et simple à mettre en place, après avoir réfléchis nous avons simplement choisit de lui faire tirer un élastique, que l'on peux recharger nous même après.

Mis à part ces quelques problèmes, tout s'est déroulé sans accros.

Elément de présentation

je met ici le document de présentation de mon projet