Les Fabriques du Ponant - Contributions de l’utilisateur [fr]

ENIB 2025 : E-BOO

2025-01-23T14:27:46Z

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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 :'' [[https://www.lespetitsdebrouillards.org/]] et '' Les Fabriques Du Ponants'' [[https://www.lesfabriquesduponant.net/]].

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==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

[[Fichier:Codage_acharné.jpeg|400px]]

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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'''
[[Fichier:CAO_ensemble_mecanique.jpeg|200px|thumb|left|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.

==Sources et documentation complémentaire==

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T14:16:11Z

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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 :'' [[https://www.lespetitsdebrouillards.org/]] et '' Les Fabriques Du Ponants'' [[https://www.lesfabriquesduponant.net/]].

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==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

[[Image:Codage_acharné.jpg]]

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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'''

===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.

==Sources et documentation complémentaire==

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

Fichier:Codage acharné.jpeg

2025-01-23T14:07:48Z

E-BOO : E-BOO a téléversé une nouvelle version de Fichier:Codage acharné.jpeg

Fichier:Codage acharné.jpeg

2025-01-23T14:06:30Z

E-BOO :

Fichier:Impression pied.jpeg

2025-01-23T14:05:46Z

E-BOO :

Fichier:Impression pivot tete.jpeg

2025-01-23T14:05:08Z

E-BOO :

Fichier:Impression support rotatif.jpeg

2025-01-23T14:04:28Z

E-BOO :

Fichier:CAO pivot tete.jpeg

2025-01-23T14:03:17Z

E-BOO : permet d'orienter la tourelle dans sa latitude

permet d'orienter la tourelle dans sa latitude

Fichier:CAO pied.jpeg

2025-01-23T13:59:38Z

E-BOO :

Fichier:CAO support rotatif.jpeg

2025-01-23T13:58:52Z

E-BOO : permet d'orienter la tourelle dans sa longitude

permet d'orienter la tourelle dans sa longitude

Fichier:CAO ensemble mecanique.jpeg

2025-01-23T13:55:17Z

E-BOO :

Fichier:Design final.jpeg

2025-01-23T13:53:43Z

E-BOO :

Fichier:Premiers pas suite.jpeg

2025-01-23T13:52:41Z

E-BOO :

Fichier:Premiers pas.jpeg

2025-01-23T13:51:32Z

E-BOO :

ENIB 2025 : E-BOO

2025-01-23T13:38:23Z

E-BOO : /* Introduction */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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 :'' [[https://www.lespetitsdebrouillards.org/]] et '' Les Fabriques Du Ponants'' [[https://www.lesfabriquesduponant.net/]].

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==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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'''

===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.

==Sources et documentation complémentaire==

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:37:31Z

E-BOO : /* Introduction */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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 :'' [[https://www.lespetitsdebrouillards.org/]] et '' Les Fabriques Du Ponants''.

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==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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'''

===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.

==Sources et documentation complémentaire==

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:36:03Z

E-BOO : /* Introduction */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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 '' et '' Les Fabriques Du Ponants''.

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==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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'''

===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.

==Sources et documentation complémentaire==

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:35:06Z

E-BOO : /* Introduction */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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'' et ''Les Fabriques Du Ponants''.

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==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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'''

===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.

==Sources et documentation complémentaire==

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:32:20Z

E-BOO : /* Troubleshouting */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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'''

===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.

==Sources et documentation complémentaire==

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:32:02Z

E-BOO : /* Les plans */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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'''

===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.

==Sources et documentation complémentaire==

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:31:48Z

E-BOO : /* Les idées */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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'''

===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.

==Sources et documentation complémentaire==

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:31:37Z

E-BOO : /* Code et Branchements électronique */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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'''

===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.

==Sources et documentation complémentaire==

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:31:17Z

E-BOO : /* Code et Branchements électronique */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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'''

===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.

==Sources et documentation complémentaire==

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:30:48Z

E-BOO : /* Les plans */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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'''

===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.

==Sources et documentation complémentaire==

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:30:33Z

E-BOO : /* Les idées */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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""

===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.

==Sources et documentation complémentaire==

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:29:57Z

E-BOO : /* Troubleshouting */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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""

===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.

==Sources et documentation complémentaire==

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:29:36Z

E-BOO : /* Troubleshouting */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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""

===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.

==Sources et documentation complémentaire==

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:28:58Z

E-BOO : /* Troubleshouting */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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""

===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.

==Sources et documentation complémentaire==

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:28:38Z

E-BOO : /* Elémlent de présentation */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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""

===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.

==Sources et documentation complémentaire==

==Elément de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:28:11Z

E-BOO : /* Troubleshouting */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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""

===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.

==Sources et documentation complémentaire==

==Elémlent de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:20:56Z

E-BOO : /* étape 5 */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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""

===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===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

problèmes : Carte Arduino, Capteur à ultra-son, Code

==Sources et documentation complémentaire==

==Elémlent de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:20:47Z

E-BOO : /* étape 4 */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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""

===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")

===étape 5===

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

problèmes : Carte Arduino, Capteur à ultra-son, Code

==Sources et documentation complémentaire==

==Elémlent de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:20:26Z

E-BOO : /* étape 3 */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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""

===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")

===étape 4===
code et branchements électroniques

===étape 5===

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

problèmes : Carte Arduino, Capteur à ultra-son, Code

==Sources et documentation complémentaire==

==Elémlent de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:13:17Z

E-BOO : /* étape 2 */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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""

===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.

===étape 3===
Assemblage

===étape 4===
code et branchements électroniques

===étape 5===

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

problèmes : Carte Arduino, Capteur à ultra-son, Code

==Sources et documentation complémentaire==

==Elémlent de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:10:59Z

E-BOO : /* Les plans */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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""

===étape 2===
Construction de la tourelle

===étape 3===
Assemblage

===étape 4===
code et branchements électroniques

===étape 5===

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

problèmes : Carte Arduino, Capteur à ultra-son, Code

==Sources et documentation complémentaire==

==Elémlent de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:10:41Z

E-BOO : /* Les plans */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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""

===étape 2===
Construction de la tourelle

===étape 3===
Assemblage

===étape 4===
code et branchements électroniques

===étape 5===

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

problèmes : Carte Arduino, Capteur à ultra-son, Code

==Sources et documentation complémentaire==

==Elémlent de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:10:26Z

E-BOO : /* Les plans */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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""

===étape 2===
Construction de la tourelle

===étape 3===
Assemblage

===étape 4===
code et branchements électroniques

===étape 5===

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

problèmes : Carte Arduino, Capteur à ultra-son, Code

==Sources et documentation complémentaire==

==Elémlent de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:06:37Z

E-BOO : /* Les plans */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

==é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===

===étape 2===
Construction de la tourelle

===étape 3===
Assemblage

===étape 4===
code et branchements électroniques

===étape 5===

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

problèmes : Carte Arduino, Capteur à ultra-son, Code

==Sources et documentation complémentaire==

==Elémlent de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:00:30Z

E-BOO : /* étape 1 */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

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

===Les plans===

===étape 2===
Construction de la tourelle

===étape 3===
Assemblage

===étape 4===
code et branchements électroniques

===étape 5===

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

problèmes : Carte Arduino, Capteur à ultra-son, Code

==Sources et documentation complémentaire==

==Elémlent de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T13:00:01Z

E-BOO : /* Code finalisé */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===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

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

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

===étape 1===
Les plans

===étape 2===
Construction de la tourelle

===étape 3===
Assemblage

===étape 4===
code et branchements électroniques

===étape 5===

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

problèmes : Carte Arduino, Capteur à ultra-son, Code

==Sources et documentation complémentaire==

==Elémlent de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T12:57:22Z

E-BOO : /* Seconde étape du code */

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é

[[Fichier:Bonhomme bras leve.png|200px]]

==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.

Vous trouverez ci-dessous comment se projeta été effectué, dans quelles conditions et les étapes de cette aventure.

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 et nous les remercions pour ça.

==outil et matériel==
{| class="wikitable"
|-
! 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)
<syntaxhighlight lang="Arduino" line>

/*
/ D1 mini \
|[ ]RST TX[ ]|
|[ ]A0 -GPIO RX[ ]|
|[ ]D0-16 5-D1[ ]| SCL
|[ ]D5-14 4-D2[ ]| SDA
|[ ]D6-12 0-D3[ ]|
|[ ]D7-13 2-D4[ ]| LED_BUILTIN
|[ ]D8-15 GND[ ]|
|[ ]3V3 . 5V[ ]|
| +---+ |
|_______|USB|_______|
*/
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");

Serial.println(distance);

delay(1000); //délais d'une seconde
if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(45);
serv_mot_2.write(0);
serv_mot_3.write(0);
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
serv_mot_1.write(0);
serv_mot_2.write(45);
serv_mot_3.write(0);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
serv_mot_1.write(0);
serv_mot_2.write(0);
serv_mot_3.write(45);
}
}

</syntaxhighlight>

===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.

<syntaxhighlight lang="Arduino" line>
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 0;
float angle_3 =0;
float next_angle_add = 1;
int something = 0;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
angle_2 = serv_mot_2.read();
angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(100); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(45);
delay(1000);
serv_mot_3.write(145);
delay(1000);
serv_mot_2.write(90);
delay(1000);
serv_mot_3.write(45);
delay(1000);
next_angle_add =1;
}
else if(distance <20){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}
</syntaxhighlight>

===Code finalisé===
Sur ce morceau de code on trouve la possibilité de modifier facilement des valeurs à partir du début du code, la tourelle possède aussi plusieurs angles de tir différents en fonction de la distance à laquelle elle se trouve de l'objet

<syntaxhighlight lang="Arduino" line>
//Ajout de la bibliothèque ultrasonic
#include <Ultrasonic.h>
#include <Servo.h>

//Création de l'objet ultrasonic
Ultrasonic ultrasonic(5, 4);
Servo serv_mot_1;
Servo serv_mot_2;
Servo serv_mot_3;
const int LED_L = 2;
const int LED_R = 15;
float angle_1 = 0;
float angle_2 = 90;
float angle_3_first =45;
float angle_3_end = 145;
float next_angle_add = 1;
int something = 0;
float angle_tilt = 45;
int delay_shoot = 1000;

void setup() {

Serial.begin(9600); // démarrage de la connexion série*
pinMode(LED_L,OUTPUT);
pinMode(LED_R,OUTPUT);
serv_mot_1.attach(16,544,2600);
serv_mot_2.attach(14,544,2600);
serv_mot_3.attach(13,544,2600);
angle_1 = serv_mot_1.read();
//angle_2 = serv_mot_2.read();
//angle_3 = serv_mot_3.read();

}

void loop() {

//utilisation de l'objet

int distance = ultrasonic.read();

// affichage de la distance dans le terminal série

Serial.print("Distance in CM: ");
Serial.println(distance);
delay(50); //délais

if (angle_1 ==0){
next_angle_add = 1;
}
else if(angle_1 ==180){
next_angle_add = -1;
}
angle_1 = angle_1 + next_angle_add;
serv_mot_1.write(angle_1);

if(distance <10){
digitalWrite(LED_L,HIGH);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;
}
else if(distance <50){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else if(distance <=100){
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,HIGH);
next_angle_add =0;
serv_mot_2.write(angle_tilt/(distance/10));
delay(delay_shoot);
serv_mot_3.write(angle_3_end);
delay(delay_shoot);
serv_mot_2.write(angle_2);
delay(delay_shoot);
serv_mot_3.write(angle_3_first);
delay(delay_shoot);
next_angle_add =1;

}
else{
digitalWrite(LED_L,LOW);
digitalWrite(LED_R,LOW);
}
}

</syntaxhighlight>

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

===étape 1===
Les plans

===étape 2===
Construction de la tourelle

===étape 3===
Assemblage

===étape 4===
code et branchements électroniques

===étape 5===

===Troubleshouting===
Quelles sont difficultés, les problèmes, quelles sont les solutions, les trucs et astuces pour que ça marche ?

problèmes : Carte Arduino, Capteur à ultra-son, Code

==Sources et documentation complémentaire==

==Elémlent de présentation==
je met ici le document de présentation de mon projet

==ne pas modifier sous cette ligne==
[[Catégorie:Enib2024]]

[[Catégorie:Enib2025]]

ENIB 2025 : E-BOO

2025-01-23T12:55:11Z

E-BOO : /* Premier test des éléments */

ENIB 2025 : E-BOO

2025-01-23T12:53:27Z

E-BOO : /* Seconde étape du code */

ENIB 2025 : E-BOO

2025-01-23T12:22:25Z

E-BOO : /* fichiers à joindre */

ENIB 2025 : E-BOO

2025-01-23T11:18:30Z

E-BOO : /* Mettre du code Arduino */

ENIB 2025 : E-BOO

2025-01-23T10:25:44Z

E-BOO : /* Troubleshouting */

ENIB 2025 : E-BOO

2025-01-22T15:52:41Z

E-BOO : /* Introduction */

ENIB 2025 : E-BOO

2025-01-22T15:49:27Z

E-BOO : /* Introduction */

ENIB 2025 : E-BOO

2025-01-22T15:47:30Z

E-BOO : /* description (résumé) */

ENIB 2025 : E-BOO

2025-01-22T15:44:37Z

E-BOO : /* outil et matériel */