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

ENIB 2022 - groupe D : Tape-Taupe

2022-01-19T14:01:44Z

Titouan Melon : /* Solénoïde */

==Photo de l'équipe==
(Ajouter une photo de nous.)

==Que fait ce projet ? ==

Des taupes montent et descendent.
Quand elles sortent de leur trou, il faut appuyer dessus pour les faire redescendre.
Quand le joueur arrive à appuyer sur la taupe avant qu'elle ne redescende, il marque des points qui sont affichés sur l'écran LCD et la taupe reste en bas.

==Liste des composants==

* 1 Arduino Mega
* Écran LCD (affichage du score)
* 7 Boutons poussoirs
* 7 solénoïdes
* Carte 2 relais (x4)
* Boitier en bois (découpe laser)
* Attache (bouton sur le solénoïde) (stylo 3D) (x7)
* Traverses (x3)
* Circlip (x7)
* Fils (x beaucoup)
* Breadboard

* Alimentation 12V
* Alimentation 5V (câble USB+PC)

==Construction==
Le dessus de la boite est percé, dans chaque trou, il y a une taupe.
==== Construction de la taupe : ====

[[Fichier:BoxPartie1.pdf|vignette]]
[[Fichier:BoxPartie2.pdf|vignette]]
[[Fichier:BoxPartie3.pdf|vignette]]

Mécanisme prévu à l'origine pour allonger la course de la taupe :
[[Fichier:Taupe originale.jpg|vignette|néant|Taupe origninale]]

[[Fichier:Une taupe.jpg|vignette|néant|Une taupe]]

==== Construction de la boite : ====
Il y a un trou pour chaque taupes dans le dessus de la boite, chaque rangés de taupes sont attachées sur une traverse.
Les traverses servent également à rigidifier la boite.

[[Fichier:Intérieur de la boite 2.jpg|vignette|néant]]

==Schéma électrique==
Un Arduino mega était nécessaire pour pouvoir gérer toutes les entrés en sorties du projet :
Pour chaque taupes (9 prévues 7 au final) :
* Commande du relais (qui commande le solénoïde)
* Entrée du bouton poussoir

===Relais===

Un relais et un interrupteur commandé par un signal de commande électriques.

Il faut d'un coté brancher le relais à la masse de l'arduino et aux 5V de l'arduino et sur un pin de l'arduino qui servira a commander le relais.

De l'autre coté il faut brancher le + et la masse de la tension voulu et le cable de sortie qui sortira soit du OV soit du 12V ici.

Ensuite quand on met le pin a 1 on active le relais et donc on sort du 12V et quand on a un 0 on sort du 0V

===Solénoide===

Il s'agit d'un électroaimant qui fait rentrer un tige monté sur ressort quand elle est alimenté et quand elle n'est pas alimenté la tige ressort grâce aux ressort.

Pour l'alimenter il faut mettre une de ses bornes a la masse et l'autre aux 12V.

Attention le solénoïde chauffe beaucoup mais c'est prévu par le fonctionnement normal.

===Bouton===

Il faut mettre une bornes aux 5V de l'arduino via une resistance et une autre sur un pin de commande, et une résistance entre ce pin et la masse.

===Ecran OLED===

[[Fichier:Schéma.jpg|vignette|néant|Schéma]]

==Code==

Tout d'abord il faut tester les composants pour s'assurer qu'ils fonctionnent tous bien

===Bouton===

Ce code permet de verifier le fonctionnement des boutons
<syntaxhighlight lang=" C++">

int cpt_taupe1 = 22; //22 represente le pin ou sera branché le bouton

void setup() {
pinMode(cpt_taupe1, INPUT); //Cette ligne permet de passer le pin en mode entré
Serial.begin(9600); //Initialise le terminal
}

void loop() {
Serial.print("T1:");
Serial.println(digitalRead(cpt_taupe1)); //Ecris l'etat du pin du bouton (0 ou 1)
}
</syntaxhighlight>

===Solénoïde===

Ce code permettra d'activer/desactiver le solenoide 1s/1s

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53; //53 represente le pin ou sera branché le bouton
void setup() {
pinMode(cmd_taupe1, OUTPUT); //Cette ligne passe le pin en sortie
}

void loop() {
digitalWrite(cmd_taupe1, HIGH); //Active le relais
delay(1000); //attends 1s
digitalWrite(cmd_taupe1, LOW); //Desactive le relais
delay(1000); //attends 1s
}
</syntaxhighlight>

===LCD===

Pour voir toute les possibilité offerte par le LCD nous vous conseillons le site electronique amateur<ref>https://electroniqueamateur.blogspot.com/2019/01/ecran-oled-sh1106-i2c-et-arduino.html</ref>.

Ici on ne fait que écrire "vous avez: xx points" sur l'écran

<syntaxhighlight lang=" C++">
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

void setup() {
display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
}

void loop() {
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran
}
</syntaxhighlight>

===Taupe===

Ici le code rassemble un solenoide et un bouton pour faire une taupe

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53;
int int_cmd_taupe1 = 1;
int cpt_taupe1 = 22;

int pts = 0;

int start = 0;
int now = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);

pinMode(cpt_taupe1, INPUT);
Serial.begin(9600);
}

void loop() {
now = millis(); //On récupère le temps dans une variable
if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
if (int_cmd_taupe1 == 1) //Si la taupe est rentré elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;
}

digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
}
</syntaxhighlight>

===Prog final===

Aprés avoir vérifié et cablé il ne reste plus qu'a tout rassembler pour le code final

Ici il n'y a que 3 taupes mais vous pouvez en rajouter a votre guise et changer le texte sur l'ecran.

<syntaxhighlight lang=" C++">

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

int cmd_taupe1 = 53;
int cmd_taupe2 = 51;
int cmd_taupe3 = 49;

int int_cmd_taupe1 = 1;
int int_cmd_taupe2 = 1;
int int_cmd_taupe3 = 1;

int cpt_taupe1 = 22;
int cpt_taupe2 = 24;
int cpt_taupe3 = 26;

int pts = 0;

int start = 0;
int now = 0;

int random_int = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);
pinMode(cmd_taupe2, OUTPUT);
pinMode(cmd_taupe3, OUTPUT);

pinMode(cpt_taupe1, INPUT);
pinMode(cpt_taupe2, INPUT);
pinMode(cpt_taupe3, INPUT);
Serial.begin(9600);

display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
randomSeed(analogRead(0)); //Initialise le random par la lecture du bruit d'un pin analogique non branché
}

void loop() {
now = millis(); //On récupère le temps dans une variable

if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
random_int = random(1, 3); //On créer un nombre random entre 1 et le nombre de taupe (ici 3)
if (int_cmd_taupe1 == 1 and random_int == 1) //Si la taupe est rentré est que le random l'indique elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;

if (int_cmd_taupe2 == 1 and random_int == 2)
int_cmd_taupe2 = 0;
else
int_cmd_taupe2 = 1;

if (int_cmd_taupe3 == 1 and random_int == 3)
int_cmd_taupe3 = 0;
else
int_cmd_taupe3 = 1;
}

//Taupe
digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci
digitalWrite(cmd_taupe2, int_cmd_taupe2);
digitalWrite(cmd_taupe3, int_cmd_taupe3);

//LCD
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
if (digitalRead(cpt_taupe2) == 1 && int_cmd_taupe2 == 0)
{
pts++;
int_cmd_taupe2 = 1;
}
if (digitalRead(cpt_taupe3) == 1 && int_cmd_taupe3 == 0)
{
pts++;
int_cmd_taupe3 = 1;
}
}
</syntaxhighlight>

[[Catégorie:Enib2022]]

ENIB 2022 - groupe D : Tape-Taupe

2022-01-19T14:01:12Z

Titouan Melon : /* Schéma électrique */

==Photo de l'équipe==
(Ajouter une photo de nous.)

==Que fait ce projet ? ==

Des taupes montent et descendent.
Quand elles sortent de leur trou, il faut appuyer dessus pour les faire redescendre.
Quand le joueur arrive à appuyer sur la taupe avant qu'elle ne redescende, il marque des points qui sont affichés sur l'écran LCD et la taupe reste en bas.

==Liste des composants==

* 1 Arduino Mega
* Écran LCD (affichage du score)
* 7 Boutons poussoirs
* 7 solénoïdes
* Carte 2 relais (x4)
* Boitier en bois (découpe laser)
* Attache (bouton sur le solénoïde) (stylo 3D) (x7)
* Traverses (x3)
* Circlip (x7)
* Fils (x beaucoup)
* Breadboard

* Alimentation 12V
* Alimentation 5V (câble USB+PC)

==Construction==
Le dessus de la boite est percé, dans chaque trou, il y a une taupe.
==== Construction de la taupe : ====

[[Fichier:BoxPartie1.pdf|vignette]]
[[Fichier:BoxPartie2.pdf|vignette]]
[[Fichier:BoxPartie3.pdf|vignette]]

Mécanisme prévu à l'origine pour allonger la course de la taupe :
[[Fichier:Taupe originale.jpg|vignette|néant|Taupe origninale]]

[[Fichier:Une taupe.jpg|vignette|néant|Une taupe]]

==== Construction de la boite : ====
Il y a un trou pour chaque taupes dans le dessus de la boite, chaque rangés de taupes sont attachées sur une traverse.
Les traverses servent également à rigidifier la boite.

[[Fichier:Intérieur de la boite 2.jpg|vignette|néant]]

==Schéma électrique==
Un Arduino mega était nécessaire pour pouvoir gérer toutes les entrés en sorties du projet :
Pour chaque taupes (9 prévues 7 au final) :
* Commande du relais (qui commande le solénoïde)
* Entrée du bouton poussoir

===Relais===

Un relais et un interrupteur commandé par un signal de commande électriques.

Il faut d'un coté brancher le relais à la masse de l'arduino et aux 5V de l'arduino et sur un pin de l'arduino qui servira a commander le relais.

De l'autre coté il faut brancher le + et la masse de la tension voulu et le cable de sortie qui sortira soit du OV soit du 12V ici.

Ensuite quand on met le pin a 1 on active le relais et donc on sort du 12V et quand on a un 0 on sort du 0V

===Solénoide===

Il s'agit d'un électroaimant qui fait rentrer un tige monté sur ressort quand elle est alimenté et quand elle n'est pas alimenté la tige ressort grâce aux ressort.

Pour l'alimenter il faut mettre une de ses bornes a la masse et l'autre aux 12V.

Attention le solénoïde chauffe beaucoup mais c'est prévu par le fonctionnement normal.

===Bouton===

Il faut mettre une bornes aux 5V de l'arduino via une resistance et une autre sur un pin de commande, et une résistance entre ce pin et la masse.

===Ecran OLED===

[[Fichier:Schéma.jpg|vignette|néant|Schéma]]

==Code==

Tout d'abord il faut tester les composants pour s'assurer qu'ils fonctionnent tous bien

===Bouton===

Ce code permet de verifier le fonctionnement des boutons
<syntaxhighlight lang=" C++">

int cpt_taupe1 = 22; //22 represente le pin ou sera branché le bouton

void setup() {
pinMode(cpt_taupe1, INPUT); //Cette ligne permet de passer le pin en mode entré
Serial.begin(9600); //Initialise le terminal
}

void loop() {
Serial.print("T1:");
Serial.println(digitalRead(cpt_taupe1)); //Ecris l'etat du pin du bouton (0 ou 1)
}
</syntaxhighlight>

===Solénoïde===

Ce code permettra d'activer/desactiver le selenoide 1s/1s

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53; //53 represente le pin ou sera branché le bouton
void setup() {
pinMode(cmd_taupe1, OUTPUT); //Cette ligne passe le pin en sortie
}

void loop() {
digitalWrite(cmd_taupe1, HIGH); //Active le relais
delay(1000); //attends 1s
digitalWrite(cmd_taupe1, LOW); //Desactive le relais
delay(1000); //attends 1s
}
</syntaxhighlight>

===LCD===

Pour voir toute les possibilité offerte par le LCD nous vous conseillons le site electronique amateur<ref>https://electroniqueamateur.blogspot.com/2019/01/ecran-oled-sh1106-i2c-et-arduino.html</ref>.

Ici on ne fait que écrire "vous avez: xx points" sur l'écran

<syntaxhighlight lang=" C++">
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

void setup() {
display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
}

void loop() {
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran
}
</syntaxhighlight>

===Taupe===

Ici le code rassemble un solenoide et un bouton pour faire une taupe

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53;
int int_cmd_taupe1 = 1;
int cpt_taupe1 = 22;

int pts = 0;

int start = 0;
int now = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);

pinMode(cpt_taupe1, INPUT);
Serial.begin(9600);
}

void loop() {
now = millis(); //On récupère le temps dans une variable
if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
if (int_cmd_taupe1 == 1) //Si la taupe est rentré elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;
}

digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
}
</syntaxhighlight>

===Prog final===

Aprés avoir vérifié et cablé il ne reste plus qu'a tout rassembler pour le code final

Ici il n'y a que 3 taupes mais vous pouvez en rajouter a votre guise et changer le texte sur l'ecran.

<syntaxhighlight lang=" C++">

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

int cmd_taupe1 = 53;
int cmd_taupe2 = 51;
int cmd_taupe3 = 49;

int int_cmd_taupe1 = 1;
int int_cmd_taupe2 = 1;
int int_cmd_taupe3 = 1;

int cpt_taupe1 = 22;
int cpt_taupe2 = 24;
int cpt_taupe3 = 26;

int pts = 0;

int start = 0;
int now = 0;

int random_int = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);
pinMode(cmd_taupe2, OUTPUT);
pinMode(cmd_taupe3, OUTPUT);

pinMode(cpt_taupe1, INPUT);
pinMode(cpt_taupe2, INPUT);
pinMode(cpt_taupe3, INPUT);
Serial.begin(9600);

display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
randomSeed(analogRead(0)); //Initialise le random par la lecture du bruit d'un pin analogique non branché
}

void loop() {
now = millis(); //On récupère le temps dans une variable

if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
random_int = random(1, 3); //On créer un nombre random entre 1 et le nombre de taupe (ici 3)
if (int_cmd_taupe1 == 1 and random_int == 1) //Si la taupe est rentré est que le random l'indique elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;

if (int_cmd_taupe2 == 1 and random_int == 2)
int_cmd_taupe2 = 0;
else
int_cmd_taupe2 = 1;

if (int_cmd_taupe3 == 1 and random_int == 3)
int_cmd_taupe3 = 0;
else
int_cmd_taupe3 = 1;
}

//Taupe
digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci
digitalWrite(cmd_taupe2, int_cmd_taupe2);
digitalWrite(cmd_taupe3, int_cmd_taupe3);

//LCD
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
if (digitalRead(cpt_taupe2) == 1 && int_cmd_taupe2 == 0)
{
pts++;
int_cmd_taupe2 = 1;
}
if (digitalRead(cpt_taupe3) == 1 && int_cmd_taupe3 == 0)
{
pts++;
int_cmd_taupe3 = 1;
}
}
</syntaxhighlight>

[[Catégorie:Enib2022]]

ENIB 2022 - groupe D : Tape-Taupe

2022-01-19T13:58:45Z

Titouan Melon : /* Bouton */

==Photo de l'équipe==
(Ajouter une photo de nous.)

==Que fait ce projet ? ==

Des taupes montent et descendent.
Quand elles sortent de leur trou, il faut appuyer dessus pour les faire redescendre.
Quand le joueur arrive à appuyer sur la taupe avant qu'elle ne redescende, il marque des points qui sont affichés sur l'écran LCD et la taupe reste en bas.

==Liste des composants==

* 1 Arduino Mega
* Écran LCD (affichage du score)
* 7 Boutons poussoirs
* 7 solénoïdes
* Carte 2 relais (x4)
* Boitier en bois (découpe laser)
* Attache (bouton sur le solénoïde) (stylo 3D) (x7)
* Traverses (x3)
* Circlip (x7)
* Fils (x beaucoup)
* Breadboard

* Alimentation 12V
* Alimentation 5V (câble USB+PC)

==Construction==
Le dessus de la boite est percé, dans chaque trou, il y a une taupe.
==== Construction de la taupe : ====

[[Fichier:BoxPartie1.pdf|vignette]]
[[Fichier:BoxPartie2.pdf|vignette]]
[[Fichier:BoxPartie3.pdf|vignette]]

Mécanisme prévu à l'origine pour allonger la course de la taupe :
[[Fichier:Taupe originale.jpg|vignette|néant|Taupe origninale]]

[[Fichier:Une taupe.jpg|vignette|néant|Une taupe]]

==== Construction de la boite : ====
Il y a un trou pour chaque taupes dans le dessus de la boite, chaque rangés de taupes sont attachées sur une traverse.
Les traverses servent également à rigidifier la boite.

[[Fichier:Intérieur de la boite 2.jpg|vignette|néant]]

==Schéma électrique==
Un Arduino mage était nécessaire pour pouvoir gérer toutes les entrés en sorties du projet :
Pour chaque taupes (9 prévues 7 au final) :
* Commande du relais (qui commande le solénoïde)
* Entrée du bouton poussoir

===Relais===

Un relais et un interrupteur commandé par un signal de commande électriques.

Il faut d'un coté brancher le relais à la masse de l'arduino et aux 5V de l'arduino et sur un pin de l'arduino qui servira a commander le relais.

De l'autre coté il faut brancher le + et la masse de la tension voulu et le cable de sortie qui sortira soit du OV soit du 12V ici.

Ensuite quand on met le pin a 1 on active le relais et donc on sort du 12V et quand on a un 0 on sort du 0V

===Solénoide===

Il s'agit d'un électroaimant qui fait rentrer un tige monté sur ressort quand elle est alimenté et quand elle n'est pas alimenté la tige ressort grâce aux ressort.

Pour l'alimenter il faut mettre une de ses bornes a la masse et l'autre aux 12V.

Attention le solénoïde chauffe beaucoup mais c'est prévu par le fonctionnement normal.

===Bouton===

Il faut mettre une bornes aux 5V de l'arduino via une resistance et une autre sur un pin de commande, et une résistance entre ce pin et la masse.

===Ecran OLED===

[[Fichier:Schéma.jpg|vignette|néant|Schéma]]

==Code==

Tout d'abord il faut tester les composants pour s'assurer qu'ils fonctionnent tous bien

===Bouton===

Ce code permet de verifier le fonctionnement des boutons
<syntaxhighlight lang=" C++">

int cpt_taupe1 = 22; //22 represente le pin ou sera branché le bouton

void setup() {
pinMode(cpt_taupe1, INPUT); //Cette ligne permet de passer le pin en mode entré
Serial.begin(9600); //Initialise le terminal
}

void loop() {
Serial.print("T1:");
Serial.println(digitalRead(cpt_taupe1)); //Ecris l'etat du pin du bouton (0 ou 1)
}
</syntaxhighlight>

===Solénoïde===

Ce code permettra d'activer/desactiver le selenoide 1s/1s

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53; //53 represente le pin ou sera branché le bouton
void setup() {
pinMode(cmd_taupe1, OUTPUT); //Cette ligne passe le pin en sortie
}

void loop() {
digitalWrite(cmd_taupe1, HIGH); //Active le relais
delay(1000); //attends 1s
digitalWrite(cmd_taupe1, LOW); //Desactive le relais
delay(1000); //attends 1s
}
</syntaxhighlight>

===LCD===

Pour voir toute les possibilité offerte par le LCD nous vous conseillons le site electronique amateur<ref>https://electroniqueamateur.blogspot.com/2019/01/ecran-oled-sh1106-i2c-et-arduino.html</ref>.

Ici on ne fait que écrire "vous avez: xx points" sur l'écran

<syntaxhighlight lang=" C++">
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

void setup() {
display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
}

void loop() {
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran
}
</syntaxhighlight>

===Taupe===

Ici le code rassemble un solenoide et un bouton pour faire une taupe

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53;
int int_cmd_taupe1 = 1;
int cpt_taupe1 = 22;

int pts = 0;

int start = 0;
int now = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);

pinMode(cpt_taupe1, INPUT);
Serial.begin(9600);
}

void loop() {
now = millis(); //On récupère le temps dans une variable
if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
if (int_cmd_taupe1 == 1) //Si la taupe est rentré elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;
}

digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
}
</syntaxhighlight>

===Prog final===

Aprés avoir vérifié et cablé il ne reste plus qu'a tout rassembler pour le code final

Ici il n'y a que 3 taupes mais vous pouvez en rajouter a votre guise et changer le texte sur l'ecran.

<syntaxhighlight lang=" C++">

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

int cmd_taupe1 = 53;
int cmd_taupe2 = 51;
int cmd_taupe3 = 49;

int int_cmd_taupe1 = 1;
int int_cmd_taupe2 = 1;
int int_cmd_taupe3 = 1;

int cpt_taupe1 = 22;
int cpt_taupe2 = 24;
int cpt_taupe3 = 26;

int pts = 0;

int start = 0;
int now = 0;

int random_int = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);
pinMode(cmd_taupe2, OUTPUT);
pinMode(cmd_taupe3, OUTPUT);

pinMode(cpt_taupe1, INPUT);
pinMode(cpt_taupe2, INPUT);
pinMode(cpt_taupe3, INPUT);
Serial.begin(9600);

display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
randomSeed(analogRead(0)); //Initialise le random par la lecture du bruit d'un pin analogique non branché
}

void loop() {
now = millis(); //On récupère le temps dans une variable

if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
random_int = random(1, 3); //On créer un nombre random entre 1 et le nombre de taupe (ici 3)
if (int_cmd_taupe1 == 1 and random_int == 1) //Si la taupe est rentré est que le random l'indique elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;

if (int_cmd_taupe2 == 1 and random_int == 2)
int_cmd_taupe2 = 0;
else
int_cmd_taupe2 = 1;

if (int_cmd_taupe3 == 1 and random_int == 3)
int_cmd_taupe3 = 0;
else
int_cmd_taupe3 = 1;
}

//Taupe
digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci
digitalWrite(cmd_taupe2, int_cmd_taupe2);
digitalWrite(cmd_taupe3, int_cmd_taupe3);

//LCD
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
if (digitalRead(cpt_taupe2) == 1 && int_cmd_taupe2 == 0)
{
pts++;
int_cmd_taupe2 = 1;
}
if (digitalRead(cpt_taupe3) == 1 && int_cmd_taupe3 == 0)
{
pts++;
int_cmd_taupe3 = 1;
}
}
</syntaxhighlight>

[[Catégorie:Enib2022]]

ENIB 2022 - groupe D : Tape-Taupe

2022-01-19T13:57:38Z

Titouan Melon : /* Solénoide */

==Photo de l'équipe==
(Ajouter une photo de nous.)

==Que fait ce projet ? ==

Des taupes montent et descendent.
Quand elles sortent de leur trou, il faut appuyer dessus pour les faire redescendre.
Quand le joueur arrive à appuyer sur la taupe avant qu'elle ne redescende, il marque des points qui sont affichés sur l'écran LCD et la taupe reste en bas.

==Liste des composants==

* 1 Arduino Mega
* Écran LCD (affichage du score)
* 7 Boutons poussoirs
* 7 solénoïdes
* Carte 2 relais (x4)
* Boitier en bois (découpe laser)
* Attache (bouton sur le solénoïde) (stylo 3D) (x7)
* Traverses (x3)
* Circlip (x7)
* Fils (x beaucoup)
* Breadboard

* Alimentation 12V
* Alimentation 5V (câble USB+PC)

==Construction==
Le dessus de la boite est percé, dans chaque trou, il y a une taupe.
==== Construction de la taupe : ====

[[Fichier:BoxPartie1.pdf|vignette]]
[[Fichier:BoxPartie2.pdf|vignette]]
[[Fichier:BoxPartie3.pdf|vignette]]

Mécanisme prévu à l'origine pour allonger la course de la taupe :
[[Fichier:Taupe originale.jpg|vignette|néant|Taupe origninale]]

[[Fichier:Une taupe.jpg|vignette|néant|Une taupe]]

==== Construction de la boite : ====
Il y a un trou pour chaque taupes dans le dessus de la boite, chaque rangés de taupes sont attachées sur une traverse.
Les traverses servent également à rigidifier la boite.

[[Fichier:Intérieur de la boite 2.jpg|vignette|néant]]

==Schéma électrique==
Un Arduino mage était nécessaire pour pouvoir gérer toutes les entrés en sorties du projet :
Pour chaque taupes (9 prévues 7 au final) :
* Commande du relais (qui commande le solénoïde)
* Entrée du bouton poussoir

===Relais===

Un relais et un interrupteur commandé par un signal de commande électriques.

Il faut d'un coté brancher le relais à la masse de l'arduino et aux 5V de l'arduino et sur un pin de l'arduino qui servira a commander le relais.

De l'autre coté il faut brancher le + et la masse de la tension voulu et le cable de sortie qui sortira soit du OV soit du 12V ici.

Ensuite quand on met le pin a 1 on active le relais et donc on sort du 12V et quand on a un 0 on sort du 0V

===Solénoide===

Il s'agit d'un électroaimant qui fait rentrer un tige monté sur ressort quand elle est alimenté et quand elle n'est pas alimenté la tige ressort grâce aux ressort.

Pour l'alimenter il faut mettre une de ses bornes a la masse et l'autre aux 12V.

Attention le solénoïde chauffe beaucoup mais c'est prévu par le fonctionnement normal.

===Bouton===

Ecran LCD.

[[Fichier:Schéma.jpg|vignette|néant|Schéma]]

==Code==

Tout d'abord il faut tester les composants pour s'assurer qu'ils fonctionnent tous bien

===Bouton===

Ce code permet de verifier le fonctionnement des boutons
<syntaxhighlight lang=" C++">

int cpt_taupe1 = 22; //22 represente le pin ou sera branché le bouton

void setup() {
pinMode(cpt_taupe1, INPUT); //Cette ligne permet de passer le pin en mode entré
Serial.begin(9600); //Initialise le terminal
}

void loop() {
Serial.print("T1:");
Serial.println(digitalRead(cpt_taupe1)); //Ecris l'etat du pin du bouton (0 ou 1)
}
</syntaxhighlight>

===Solénoïde===

Ce code permettra d'activer/desactiver le selenoide 1s/1s

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53; //53 represente le pin ou sera branché le bouton
void setup() {
pinMode(cmd_taupe1, OUTPUT); //Cette ligne passe le pin en sortie
}

void loop() {
digitalWrite(cmd_taupe1, HIGH); //Active le relais
delay(1000); //attends 1s
digitalWrite(cmd_taupe1, LOW); //Desactive le relais
delay(1000); //attends 1s
}
</syntaxhighlight>

===LCD===

Pour voir toute les possibilité offerte par le LCD nous vous conseillons le site electronique amateur<ref>https://electroniqueamateur.blogspot.com/2019/01/ecran-oled-sh1106-i2c-et-arduino.html</ref>.

Ici on ne fait que écrire "vous avez: xx points" sur l'écran

<syntaxhighlight lang=" C++">
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

void setup() {
display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
}

void loop() {
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran
}
</syntaxhighlight>

===Taupe===

Ici le code rassemble un solenoide et un bouton pour faire une taupe

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53;
int int_cmd_taupe1 = 1;
int cpt_taupe1 = 22;

int pts = 0;

int start = 0;
int now = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);

pinMode(cpt_taupe1, INPUT);
Serial.begin(9600);
}

void loop() {
now = millis(); //On récupère le temps dans une variable
if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
if (int_cmd_taupe1 == 1) //Si la taupe est rentré elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;
}

digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
}
</syntaxhighlight>

===Prog final===

Aprés avoir vérifié et cablé il ne reste plus qu'a tout rassembler pour le code final

Ici il n'y a que 3 taupes mais vous pouvez en rajouter a votre guise et changer le texte sur l'ecran.

<syntaxhighlight lang=" C++">

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

int cmd_taupe1 = 53;
int cmd_taupe2 = 51;
int cmd_taupe3 = 49;

int int_cmd_taupe1 = 1;
int int_cmd_taupe2 = 1;
int int_cmd_taupe3 = 1;

int cpt_taupe1 = 22;
int cpt_taupe2 = 24;
int cpt_taupe3 = 26;

int pts = 0;

int start = 0;
int now = 0;

int random_int = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);
pinMode(cmd_taupe2, OUTPUT);
pinMode(cmd_taupe3, OUTPUT);

pinMode(cpt_taupe1, INPUT);
pinMode(cpt_taupe2, INPUT);
pinMode(cpt_taupe3, INPUT);
Serial.begin(9600);

display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
randomSeed(analogRead(0)); //Initialise le random par la lecture du bruit d'un pin analogique non branché
}

void loop() {
now = millis(); //On récupère le temps dans une variable

if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
random_int = random(1, 3); //On créer un nombre random entre 1 et le nombre de taupe (ici 3)
if (int_cmd_taupe1 == 1 and random_int == 1) //Si la taupe est rentré est que le random l'indique elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;

if (int_cmd_taupe2 == 1 and random_int == 2)
int_cmd_taupe2 = 0;
else
int_cmd_taupe2 = 1;

if (int_cmd_taupe3 == 1 and random_int == 3)
int_cmd_taupe3 = 0;
else
int_cmd_taupe3 = 1;
}

//Taupe
digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci
digitalWrite(cmd_taupe2, int_cmd_taupe2);
digitalWrite(cmd_taupe3, int_cmd_taupe3);

//LCD
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
if (digitalRead(cpt_taupe2) == 1 && int_cmd_taupe2 == 0)
{
pts++;
int_cmd_taupe2 = 1;
}
if (digitalRead(cpt_taupe3) == 1 && int_cmd_taupe3 == 0)
{
pts++;
int_cmd_taupe3 = 1;
}
}
</syntaxhighlight>

[[Catégorie:Enib2022]]

ENIB 2022 - groupe D : Tape-Taupe

2022-01-19T13:51:37Z

Titouan Melon : /* Relais */

==Photo de l'équipe==
(Ajouter une photo de nous.)

==Que fait ce projet ? ==

Des taupes montent et descendent.
Quand elles sortent de leur trou, il faut appuyer dessus pour les faire redescendre.
Quand le joueur arrive à appuyer sur la taupe avant qu'elle ne redescende, il marque des points qui sont affichés sur l'écran LCD et la taupe reste en bas.

==Liste des composants==

* 1 Arduino Mega
* Écran LCD (affichage du score)
* 7 Boutons poussoirs
* 7 solénoïdes
* Carte 2 relais (x4)
* Boitier en bois (découpe laser)
* Attache (bouton sur le solénoïde) (stylo 3D) (x7)
* Traverses (x3)
* Circlip (x7)
* Fils (x beaucoup)
* Breadboard

* Alimentation 12V
* Alimentation 5V (câble USB+PC)

==Construction==
Le dessus de la boite est percé, dans chaque trou, il y a une taupe.
==== Construction de la taupe : ====

[[Fichier:BoxPartie1.pdf|vignette]]
[[Fichier:BoxPartie2.pdf|vignette]]
[[Fichier:BoxPartie3.pdf|vignette]]

Mécanisme prévu à l'origine pour allonger la course de la taupe :
[[Fichier:Taupe originale.jpg|vignette|néant|Taupe origninale]]

[[Fichier:Une taupe.jpg|vignette|néant|Une taupe]]

==== Construction de la boite : ====
Il y a un trou pour chaque taupes dans le dessus de la boite, chaque rangés de taupes sont attachées sur une traverse.
Les traverses servent également à rigidifier la boite.

[[Fichier:Intérieur de la boite 2.jpg|vignette|néant]]

==Schéma électrique==
Un Arduino mage était nécessaire pour pouvoir gérer toutes les entrés en sorties du projet :
Pour chaque taupes (9 prévues 7 au final) :
* Commande du relais (qui commande le solénoïde)
* Entrée du bouton poussoir

===Relais===

Un relais et un interrupteur commandé par un signal de commande électriques.

Il faut d'un coté brancher le relais à la masse de l'arduino et aux 5V de l'arduino et sur un pin de l'arduino qui servira a commander le relais.

De l'autre coté il faut brancher le + et la masse de la tension voulu et le cable de sortie qui sortira soit du OV soit du 12V ici.

Ensuite quand on met le pin a 1 on active le relais et donc on sort du 12V et quand on a un 0 on sort du 0V

===Solénoide===

===Bouton===

Ecran LCD.

[[Fichier:Schéma.jpg|vignette|néant|Schéma]]

==Code==

Tout d'abord il faut tester les composants pour s'assurer qu'ils fonctionnent tous bien

===Bouton===

Ce code permet de verifier le fonctionnement des boutons
<syntaxhighlight lang=" C++">

int cpt_taupe1 = 22; //22 represente le pin ou sera branché le bouton

void setup() {
pinMode(cpt_taupe1, INPUT); //Cette ligne permet de passer le pin en mode entré
Serial.begin(9600); //Initialise le terminal
}

void loop() {
Serial.print("T1:");
Serial.println(digitalRead(cpt_taupe1)); //Ecris l'etat du pin du bouton (0 ou 1)
}
</syntaxhighlight>

===Solénoïde===

Ce code permettra d'activer/desactiver le selenoide 1s/1s

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53; //53 represente le pin ou sera branché le bouton
void setup() {
pinMode(cmd_taupe1, OUTPUT); //Cette ligne passe le pin en sortie
}

void loop() {
digitalWrite(cmd_taupe1, HIGH); //Active le relais
delay(1000); //attends 1s
digitalWrite(cmd_taupe1, LOW); //Desactive le relais
delay(1000); //attends 1s
}
</syntaxhighlight>

===LCD===

Pour voir toute les possibilité offerte par le LCD nous vous conseillons le site electronique amateur<ref>https://electroniqueamateur.blogspot.com/2019/01/ecran-oled-sh1106-i2c-et-arduino.html</ref>.

Ici on ne fait que écrire "vous avez: xx points" sur l'écran

<syntaxhighlight lang=" C++">
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

void setup() {
display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
}

void loop() {
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran
}
</syntaxhighlight>

===Taupe===

Ici le code rassemble un solenoide et un bouton pour faire une taupe

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53;
int int_cmd_taupe1 = 1;
int cpt_taupe1 = 22;

int pts = 0;

int start = 0;
int now = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);

pinMode(cpt_taupe1, INPUT);
Serial.begin(9600);
}

void loop() {
now = millis(); //On récupère le temps dans une variable
if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
if (int_cmd_taupe1 == 1) //Si la taupe est rentré elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;
}

digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
}
</syntaxhighlight>

===Prog final===

Aprés avoir vérifié et cablé il ne reste plus qu'a tout rassembler pour le code final

Ici il n'y a que 3 taupes mais vous pouvez en rajouter a votre guise et changer le texte sur l'ecran.

<syntaxhighlight lang=" C++">

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

int cmd_taupe1 = 53;
int cmd_taupe2 = 51;
int cmd_taupe3 = 49;

int int_cmd_taupe1 = 1;
int int_cmd_taupe2 = 1;
int int_cmd_taupe3 = 1;

int cpt_taupe1 = 22;
int cpt_taupe2 = 24;
int cpt_taupe3 = 26;

int pts = 0;

int start = 0;
int now = 0;

int random_int = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);
pinMode(cmd_taupe2, OUTPUT);
pinMode(cmd_taupe3, OUTPUT);

pinMode(cpt_taupe1, INPUT);
pinMode(cpt_taupe2, INPUT);
pinMode(cpt_taupe3, INPUT);
Serial.begin(9600);

display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
randomSeed(analogRead(0)); //Initialise le random par la lecture du bruit d'un pin analogique non branché
}

void loop() {
now = millis(); //On récupère le temps dans une variable

if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
random_int = random(1, 3); //On créer un nombre random entre 1 et le nombre de taupe (ici 3)
if (int_cmd_taupe1 == 1 and random_int == 1) //Si la taupe est rentré est que le random l'indique elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;

if (int_cmd_taupe2 == 1 and random_int == 2)
int_cmd_taupe2 = 0;
else
int_cmd_taupe2 = 1;

if (int_cmd_taupe3 == 1 and random_int == 3)
int_cmd_taupe3 = 0;
else
int_cmd_taupe3 = 1;
}

//Taupe
digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci
digitalWrite(cmd_taupe2, int_cmd_taupe2);
digitalWrite(cmd_taupe3, int_cmd_taupe3);

//LCD
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
if (digitalRead(cpt_taupe2) == 1 && int_cmd_taupe2 == 0)
{
pts++;
int_cmd_taupe2 = 1;
}
if (digitalRead(cpt_taupe3) == 1 && int_cmd_taupe3 == 0)
{
pts++;
int_cmd_taupe3 = 1;
}
}
</syntaxhighlight>

[[Catégorie:Enib2022]]

ENIB 2022 - groupe D : Tape-Taupe

2022-01-19T13:46:25Z

Titouan Melon : /* Schéma électrique */

==Photo de l'équipe==
(Ajouter une photo de nous.)

==Que fait ce projet ? ==

Des taupes montent et descendent.
Quand elles sortent de leur trou, il faut appuyer dessus pour les faire redescendre.
Quand le joueur arrive à appuyer sur la taupe avant qu'elle ne redescende, il marque des points qui sont affichés sur l'écran LCD et la taupe reste en bas.

==Liste des composants==

* 1 Arduino Mega
* Écran LCD (affichage du score)
* 7 Boutons poussoirs
* 7 solénoïdes
* Carte 2 relais (x4)
* Boitier en bois (découpe laser)
* Attache (bouton sur le solénoïde) (stylo 3D) (x7)
* Traverses (x3)
* Circlip (x7)
* Fils (x beaucoup)
* Breadboard

* Alimentation 12V
* Alimentation 5V (câble USB+PC)

==Construction==
Le dessus de la boite est percé, dans chaque trou, il y a une taupe.
==== Construction de la taupe : ====

[[Fichier:BoxPartie1.pdf|vignette]]
[[Fichier:BoxPartie2.pdf|vignette]]
[[Fichier:BoxPartie3.pdf|vignette]]

Mécanisme prévu à l'origine pour allonger la course de la taupe :
[[Fichier:Taupe originale.jpg|vignette|néant|Taupe origninale]]

[[Fichier:Une taupe.jpg|vignette|néant|Une taupe]]

==== Construction de la boite : ====
Il y a un trou pour chaque taupes dans le dessus de la boite, chaque rangés de taupes sont attachées sur une traverse.
Les traverses servent également à rigidifier la boite.

[[Fichier:Intérieur de la boite 2.jpg|vignette|néant]]

==Schéma électrique==
Un Arduino mage était nécessaire pour pouvoir gérer toutes les entrés en sorties du projet :
Pour chaque taupes (9 prévues 7 au final) :
* Commande du relais (qui commande le solénoïde)
* Entrée du bouton poussoir

===Relais===

===Solénoide===

===Bouton===

Ecran LCD.

[[Fichier:Schéma.jpg|vignette|néant|Schéma]]

==Code==

Tout d'abord il faut tester les composants pour s'assurer qu'ils fonctionnent tous bien

===Bouton===

Ce code permet de verifier le fonctionnement des boutons
<syntaxhighlight lang=" C++">

int cpt_taupe1 = 22; //22 represente le pin ou sera branché le bouton

void setup() {
pinMode(cpt_taupe1, INPUT); //Cette ligne permet de passer le pin en mode entré
Serial.begin(9600); //Initialise le terminal
}

void loop() {
Serial.print("T1:");
Serial.println(digitalRead(cpt_taupe1)); //Ecris l'etat du pin du bouton (0 ou 1)
}
</syntaxhighlight>

===Solénoïde===

Ce code permettra d'activer/desactiver le selenoide 1s/1s

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53; //53 represente le pin ou sera branché le bouton
void setup() {
pinMode(cmd_taupe1, OUTPUT); //Cette ligne passe le pin en sortie
}

void loop() {
digitalWrite(cmd_taupe1, HIGH); //Active le relais
delay(1000); //attends 1s
digitalWrite(cmd_taupe1, LOW); //Desactive le relais
delay(1000); //attends 1s
}
</syntaxhighlight>

===LCD===

Pour voir toute les possibilité offerte par le LCD nous vous conseillons le site electronique amateur<ref>https://electroniqueamateur.blogspot.com/2019/01/ecran-oled-sh1106-i2c-et-arduino.html</ref>.

Ici on ne fait que écrire "vous avez: xx points" sur l'écran

<syntaxhighlight lang=" C++">
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

void setup() {
display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
}

void loop() {
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran
}
</syntaxhighlight>

===Taupe===

Ici le code rassemble un solenoide et un bouton pour faire une taupe

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53;
int int_cmd_taupe1 = 1;
int cpt_taupe1 = 22;

int pts = 0;

int start = 0;
int now = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);

pinMode(cpt_taupe1, INPUT);
Serial.begin(9600);
}

void loop() {
now = millis(); //On récupère le temps dans une variable
if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
if (int_cmd_taupe1 == 1) //Si la taupe est rentré elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;
}

digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
}
</syntaxhighlight>

===Prog final===

Aprés avoir vérifié et cablé il ne reste plus qu'a tout rassembler pour le code final

Ici il n'y a que 3 taupes mais vous pouvez en rajouter a votre guise et changer le texte sur l'ecran.

<syntaxhighlight lang=" C++">

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

int cmd_taupe1 = 53;
int cmd_taupe2 = 51;
int cmd_taupe3 = 49;

int int_cmd_taupe1 = 1;
int int_cmd_taupe2 = 1;
int int_cmd_taupe3 = 1;

int cpt_taupe1 = 22;
int cpt_taupe2 = 24;
int cpt_taupe3 = 26;

int pts = 0;

int start = 0;
int now = 0;

int random_int = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);
pinMode(cmd_taupe2, OUTPUT);
pinMode(cmd_taupe3, OUTPUT);

pinMode(cpt_taupe1, INPUT);
pinMode(cpt_taupe2, INPUT);
pinMode(cpt_taupe3, INPUT);
Serial.begin(9600);

display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
randomSeed(analogRead(0)); //Initialise le random par la lecture du bruit d'un pin analogique non branché
}

void loop() {
now = millis(); //On récupère le temps dans une variable

if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
random_int = random(1, 3); //On créer un nombre random entre 1 et le nombre de taupe (ici 3)
if (int_cmd_taupe1 == 1 and random_int == 1) //Si la taupe est rentré est que le random l'indique elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;

if (int_cmd_taupe2 == 1 and random_int == 2)
int_cmd_taupe2 = 0;
else
int_cmd_taupe2 = 1;

if (int_cmd_taupe3 == 1 and random_int == 3)
int_cmd_taupe3 = 0;
else
int_cmd_taupe3 = 1;
}

//Taupe
digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci
digitalWrite(cmd_taupe2, int_cmd_taupe2);
digitalWrite(cmd_taupe3, int_cmd_taupe3);

//LCD
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
if (digitalRead(cpt_taupe2) == 1 && int_cmd_taupe2 == 0)
{
pts++;
int_cmd_taupe2 = 1;
}
if (digitalRead(cpt_taupe3) == 1 && int_cmd_taupe3 == 0)
{
pts++;
int_cmd_taupe3 = 1;
}
}
</syntaxhighlight>

[[Catégorie:Enib2022]]

ENIB 2022 - Groupe D : Bateau pirate "Larguez vos amarres"

2022-01-19T13:29:30Z

Titouan Melon : /* Schéma électrique */

[[Fichier:Logo-enib.png|300px|right]]
== Que fait ce projet ? ==

Etudiants en 3eme année à l'ENIB, nous avons pu dans le cadre de notre intersemestre et en collaboration avec les petit débrouillards participer à un "Hackaton" avec pour sujet la '''Fête foraine''', nous avons donc fait le choix de créer un bateau pirate miniature comme on peut en voir dans de nombreuse fête foraine.
<gallery>
Image:BateauPirate2022.jpg|Rendu réaliste
Image:BateauPirateCAO2022.jpg|Partie CAO
Image:BateauPirateArduino2022.JPG|Cablage Arduino
</gallery>

== Les membres du projet ==
*Paul TESSON
*Julien SORIANO
*Florian ARNOUX
*Francisco RODRIGUES

==Liste des composants==
{|align="center" class="wikitable"
! rowspan="1" | Produit
!! width="33%" rowspan="1" |Caractéristiques
!! width="33%" rowspan="1" |Quantité
|-
||Arduino
|rowspan="1" colspan="1" align="center" valign="center" |Mega 2560
|rowspan="1" colspan="1" align="center" valign="center" |1
|-
||Câbles
|rowspan="1" colspan="1" align="center" valign="center" |Équipés de duponts (mâles et femelles)
|rowspan="1" colspan="1" align="center" valign="center" |Environ 20
|-
||Breadboard
|rowspan="1" colspan="1" align="center" valign="center" |-
|rowspan="1" colspan="1" align="center" valign="center" |1
|-
||Pont en H
|rowspan="1" colspan="1" align="center" valign="center" |L298N
|rowspan="1" colspan="1" align="center" valign="center" |1
|-
||Roulements à billes
|rowspan="1" colspan="1" align="center" valign="center" |d=8mm ; D=22mm
|rowspan="1" colspan="1" align="center" valign="center" |2
|-
||Médium
|rowspan="1" colspan="1" align="center" valign="center" |Plaques l=300mm ; L=600mm
|rowspan="1" colspan="1" align="center" valign="center" |4
|-
||Haut parleur
|rowspan="1" colspan="1" align="center" valign="center" |Simple
|rowspan="1" colspan="1" align="center" valign="center" |1
|-
||Lecteur de microSD
|rowspan="1" colspan="1" align="center" valign="center" |1528-1462-ND de chez Adafruit Industries LLC
|rowspan="1" colspan="1" align="center" valign="center" |1
|-
||Bande LED
|rowspan="1" colspan="1" align="center" valign="center" |-
|rowspan="1" colspan="1" align="center" valign="center" |1
|-
||Axe
|rowspan="1" colspan="1" align="center" valign="center" |D=8mm
|rowspan="1" colspan="1" align="center" valign="center" |1
|}

== Plan des pièces à réaliser au laser ==
Ces plans ont été élaborés pour des plaques de médium de 300×600mm
{|cellspacing="0" cellpadding="2" style="border:1px solid #19C533;background-color:#52E969; margin-bottom:5px;" width="450"
|'''Fichiers 3D'''
|style="text-align: center;"|[https://www.wiki.lesfabriquesduponant.net/images/b/b7/PlansLaserBateauPirate2022-1.svg Plan 1] [https://www.wiki.lesfabriquesduponant.net/images/3/3b/PlansLaserBateauPirate2022-3.svg Plan 3]<br/>[https://www.wiki.lesfabriquesduponant.net/images/8/88/PlansLaserBateauPirate2022-2.svg Plan 2] [https://www.wiki.lesfabriquesduponant.net/images/6/6e/PlansLaserBateauPirate2022-4.svg Plan 4]
|}

==Schéma électrique==
[[Image:BateauPirateARDSH2022.png|1000px|center]]

==Musiques==
Lien : https://www.youtube.com/watch?v=gVzQWP4bKPA

==Code==
{|align="center" class="wikitable"
! rowspan="1" | Musique
!! width="50%" rowspan="1" | Moteur
|-
||<pre>
#include <DFPlayer_Mini_Mp3.h>
#include <SoftwareSerial.h>

int i=0;

void setup() {
Serial.begin (9600);
mp3_set_serial (Serial);
mp3_set_volume (25);
}

void loop () {
while (i<3){
i++;
mp3_play(i);
delay(119000);
i=i%2;
}
}
</pre>
|rowspan="1" colspan="1" align="left" valign="center" |<pre>
// Pont en H L298N

//Ports de commande du moteur B
int motorPin1 = 8;
int motorPin2 = 9;
int enablePin = 5;

// Vitesse du moteur
int state = 0;

void setup() {
Serial.begin(9600);
Serial.println(F("Initialize System"));
//Init btn

// Initialisation du port série
Serial.begin(9600);
}

void loop() {

if (Serial.available() > 0)
{
// Lecture de l'entier passé au port série
state = Serial.parseInt();

//
// Sens du mouvement
//
if (state > 0) // avant
{
digitalWrite(motorPin1, HIGH);
digitalWrite(motorPin2, LOW);
Serial.print("Avant ");
Serial.println(state);
}
else if (state < 0) // arrière
{
digitalWrite(motorPin1, LOW);
digitalWrite(motorPin2, HIGH);
Serial.print("Arriere ");
Serial.println(state);
}
else // Stop (freinage)
{
digitalWrite(motorPin1, HIGH);
digitalWrite(motorPin2, HIGH);
Serial.println("Stop");
}
//
// Vitesse du mouvement
//
analogWrite(enablePin, abs(state));
}
delay(100);
}
</pre>
|}

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe D : Tape-Taupe

2022-01-19T13:24:27Z

Titouan Melon : Annulation des modifications 19303 de Titouan Melon (discussion)

==Photo de l'équipe==
(Ajouter une photo de nous.)

==Que fait ce projet ? ==

Des taupes montent et descendent.
Quand elles sortent de leur trou, il faut appuyer dessus pour les faire redescendre.
Quand le joueur arrive à appuyer sur la taupe avant qu'elle ne redescende, il marque des points qui sont affichés sur l'écran LCD et la taupe reste en bas.

==Liste des composants==

* 1 Arduino Mega
* Écran LCD (affichage du score)
* 7 Boutons poussoirs
* 7 solénoïdes
* Carte 2 relais (x4)
* Boitier en bois (découpe laser)
* Attache (bouton sur le solénoïde) (stylo 3D) (x7)
* Traverses (x3)
* Circlip (x7)
* Fils (x beaucoup)
* Breadboard

* Alimentation 12V
* Alimentation 5V (câble USB+PC)

==Construction==
Le dessus de la boite est percé, dans chaque trou, il y a une taupe.
==== Construction de la taupe : ====

[[Fichier:BoxPartie1.pdf|vignette]]
[[Fichier:BoxPartie2.pdf|vignette]]
[[Fichier:BoxPartie3.pdf|vignette]]

Mécanisme prévu à l'origine pour allonger la course de la taupe :
[[Fichier:Taupe originale.jpg|vignette|néant|Taupe origninale]]

[[Fichier:Une taupe.jpg|vignette|néant|Une taupe]]

==== Construction de la boite : ====
Il y a un trou pour chaque taupes dans le dessus de la boite, chaque rangés de taupes sont attachées sur une traverse.
Les traverses servent également à rigidifier la boite.

[[Fichier:Intérieur de la boite 2.jpg|vignette|néant]]

==Schéma électrique==
Un Arduino mage était nécessaire pour pouvoir gérer toutes les entrés en sorties du projet :
Pour chaque taupes (9 prévues 7 au final) :
* Commande du relais (qui commande le solénoïde)
* Entrée du bouton poussoir

Ecran LCD.

[[Fichier:Schéma.jpg|vignette|néant|Schéma]]

==Code==

Tout d'abord il faut tester les composants pour s'assurer qu'ils fonctionnent tous bien

===Bouton===

Ce code permet de verifier le fonctionnement des boutons
<syntaxhighlight lang=" C++">

int cpt_taupe1 = 22; //22 represente le pin ou sera branché le bouton

void setup() {
pinMode(cpt_taupe1, INPUT); //Cette ligne permet de passer le pin en mode entré
Serial.begin(9600); //Initialise le terminal
}

void loop() {
Serial.print("T1:");
Serial.println(digitalRead(cpt_taupe1)); //Ecris l'etat du pin du bouton (0 ou 1)
}
</syntaxhighlight>

===Solénoïde===

Ce code permettra d'activer/desactiver le selenoide 1s/1s

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53; //53 represente le pin ou sera branché le bouton
void setup() {
pinMode(cmd_taupe1, OUTPUT); //Cette ligne passe le pin en sortie
}

void loop() {
digitalWrite(cmd_taupe1, HIGH); //Active le relais
delay(1000); //attends 1s
digitalWrite(cmd_taupe1, LOW); //Desactive le relais
delay(1000); //attends 1s
}
</syntaxhighlight>

===LCD===

Pour voir toute les possibilité offerte par le LCD nous vous conseillons le site electronique amateur<ref>https://electroniqueamateur.blogspot.com/2019/01/ecran-oled-sh1106-i2c-et-arduino.html</ref>.

Ici on ne fait que écrire "vous avez: xx points" sur l'écran

<syntaxhighlight lang=" C++">
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

void setup() {
display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
}

void loop() {
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran
}
</syntaxhighlight>

===Taupe===

Ici le code rassemble un solenoide et un bouton pour faire une taupe

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53;
int int_cmd_taupe1 = 1;
int cpt_taupe1 = 22;

int pts = 0;

int start = 0;
int now = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);

pinMode(cpt_taupe1, INPUT);
Serial.begin(9600);
}

void loop() {
now = millis(); //On récupère le temps dans une variable
if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
if (int_cmd_taupe1 == 1) //Si la taupe est rentré elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;
}

digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
}
</syntaxhighlight>

===Prog final===

Aprés avoir vérifié et cablé il ne reste plus qu'a tout rassembler pour le code final

Ici il n'y a que 3 taupes mais vous pouvez en rajouter a votre guise et changer le texte sur l'ecran.

<syntaxhighlight lang=" C++">

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

int cmd_taupe1 = 53;
int cmd_taupe2 = 51;
int cmd_taupe3 = 49;

int int_cmd_taupe1 = 1;
int int_cmd_taupe2 = 1;
int int_cmd_taupe3 = 1;

int cpt_taupe1 = 22;
int cpt_taupe2 = 24;
int cpt_taupe3 = 26;

int pts = 0;

int start = 0;
int now = 0;

int random_int = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);
pinMode(cmd_taupe2, OUTPUT);
pinMode(cmd_taupe3, OUTPUT);

pinMode(cpt_taupe1, INPUT);
pinMode(cpt_taupe2, INPUT);
pinMode(cpt_taupe3, INPUT);
Serial.begin(9600);

display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
randomSeed(analogRead(0)); //Initialise le random par la lecture du bruit d'un pin analogique non branché
}

void loop() {
now = millis(); //On récupère le temps dans une variable

if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
random_int = random(1, 3); //On créer un nombre random entre 1 et le nombre de taupe (ici 3)
if (int_cmd_taupe1 == 1 and random_int == 1) //Si la taupe est rentré est que le random l'indique elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;

if (int_cmd_taupe2 == 1 and random_int == 2)
int_cmd_taupe2 = 0;
else
int_cmd_taupe2 = 1;

if (int_cmd_taupe3 == 1 and random_int == 3)
int_cmd_taupe3 = 0;
else
int_cmd_taupe3 = 1;
}

//Taupe
digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci
digitalWrite(cmd_taupe2, int_cmd_taupe2);
digitalWrite(cmd_taupe3, int_cmd_taupe3);

//LCD
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
if (digitalRead(cpt_taupe2) == 1 && int_cmd_taupe2 == 0)
{
pts++;
int_cmd_taupe2 = 1;
}
if (digitalRead(cpt_taupe3) == 1 && int_cmd_taupe3 == 0)
{
pts++;
int_cmd_taupe3 = 1;
}
}
</syntaxhighlight>

[[Catégorie:Enib2022]]

ENIB 2022 - groupe D : Tape-Taupe

2022-01-19T13:23:55Z

Titouan Melon : /* Construction de la taupe : */

==Photo de l'équipe==
(Ajouter une photo de nous.)

==Que fait ce projet ? ==

Des taupes montent et descendent.
Quand elles sortent de leur trou, il faut appuyer dessus pour les faire redescendre.
Quand le joueur arrive à appuyer sur la taupe avant qu'elle ne redescende, il marque des points qui sont affichés sur l'écran LCD et la taupe reste en bas.

==Liste des composants==

* 1 Arduino Mega
* Écran LCD (affichage du score)
* 7 Boutons poussoirs
* 7 solénoïdes
* Carte 2 relais (x4)
* Boitier en bois (découpe laser)
* Attache (bouton sur le solénoïde) (stylo 3D) (x7)
* Traverses (x3)
* Circlip (x7)
* Fils (x beaucoup)
* Breadboard

* Alimentation 12V
* Alimentation 5V (câble USB+PC)

==Construction==
Le dessus de la boite est percé, dans chaque trou, il y a une taupe.
==== Construction de la taupe : ====

[[BoxPartie1.pdf|vignette]]
[[BoxPartie2.pdf|vignette]]
[[BoxPartie3.pdf|vignette]]

Mécanisme prévu à l'origine pour allonger la course de la taupe :
[[Fichier:Taupe originale.jpg|vignette|néant|Taupe origninale]]

[[Fichier:Une taupe.jpg|vignette|néant|Une taupe]]

==== Construction de la boite : ====
Il y a un trou pour chaque taupes dans le dessus de la boite, chaque rangés de taupes sont attachées sur une traverse.
Les traverses servent également à rigidifier la boite.

[[Fichier:Intérieur de la boite 2.jpg|vignette|néant]]

==Schéma électrique==
Un Arduino mage était nécessaire pour pouvoir gérer toutes les entrés en sorties du projet :
Pour chaque taupes (9 prévues 7 au final) :
* Commande du relais (qui commande le solénoïde)
* Entrée du bouton poussoir

Ecran LCD.

[[Fichier:Schéma.jpg|vignette|néant|Schéma]]

==Code==

Tout d'abord il faut tester les composants pour s'assurer qu'ils fonctionnent tous bien

===Bouton===

Ce code permet de verifier le fonctionnement des boutons
<syntaxhighlight lang=" C++">

int cpt_taupe1 = 22; //22 represente le pin ou sera branché le bouton

void setup() {
pinMode(cpt_taupe1, INPUT); //Cette ligne permet de passer le pin en mode entré
Serial.begin(9600); //Initialise le terminal
}

void loop() {
Serial.print("T1:");
Serial.println(digitalRead(cpt_taupe1)); //Ecris l'etat du pin du bouton (0 ou 1)
}
</syntaxhighlight>

===Solénoïde===

Ce code permettra d'activer/desactiver le selenoide 1s/1s

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53; //53 represente le pin ou sera branché le bouton
void setup() {
pinMode(cmd_taupe1, OUTPUT); //Cette ligne passe le pin en sortie
}

void loop() {
digitalWrite(cmd_taupe1, HIGH); //Active le relais
delay(1000); //attends 1s
digitalWrite(cmd_taupe1, LOW); //Desactive le relais
delay(1000); //attends 1s
}
</syntaxhighlight>

===LCD===

Pour voir toute les possibilité offerte par le LCD nous vous conseillons le site electronique amateur<ref>https://electroniqueamateur.blogspot.com/2019/01/ecran-oled-sh1106-i2c-et-arduino.html</ref>.

Ici on ne fait que écrire "vous avez: xx points" sur l'écran

<syntaxhighlight lang=" C++">
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

void setup() {
display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
}

void loop() {
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran
}
</syntaxhighlight>

===Taupe===

Ici le code rassemble un solenoide et un bouton pour faire une taupe

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53;
int int_cmd_taupe1 = 1;
int cpt_taupe1 = 22;

int pts = 0;

int start = 0;
int now = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);

pinMode(cpt_taupe1, INPUT);
Serial.begin(9600);
}

void loop() {
now = millis(); //On récupère le temps dans une variable
if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
if (int_cmd_taupe1 == 1) //Si la taupe est rentré elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;
}

digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
}
</syntaxhighlight>

===Prog final===

Aprés avoir vérifié et cablé il ne reste plus qu'a tout rassembler pour le code final

Ici il n'y a que 3 taupes mais vous pouvez en rajouter a votre guise et changer le texte sur l'ecran.

<syntaxhighlight lang=" C++">

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

int cmd_taupe1 = 53;
int cmd_taupe2 = 51;
int cmd_taupe3 = 49;

int int_cmd_taupe1 = 1;
int int_cmd_taupe2 = 1;
int int_cmd_taupe3 = 1;

int cpt_taupe1 = 22;
int cpt_taupe2 = 24;
int cpt_taupe3 = 26;

int pts = 0;

int start = 0;
int now = 0;

int random_int = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);
pinMode(cmd_taupe2, OUTPUT);
pinMode(cmd_taupe3, OUTPUT);

pinMode(cpt_taupe1, INPUT);
pinMode(cpt_taupe2, INPUT);
pinMode(cpt_taupe3, INPUT);
Serial.begin(9600);

display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
randomSeed(analogRead(0)); //Initialise le random par la lecture du bruit d'un pin analogique non branché
}

void loop() {
now = millis(); //On récupère le temps dans une variable

if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
random_int = random(1, 3); //On créer un nombre random entre 1 et le nombre de taupe (ici 3)
if (int_cmd_taupe1 == 1 and random_int == 1) //Si la taupe est rentré est que le random l'indique elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;

if (int_cmd_taupe2 == 1 and random_int == 2)
int_cmd_taupe2 = 0;
else
int_cmd_taupe2 = 1;

if (int_cmd_taupe3 == 1 and random_int == 3)
int_cmd_taupe3 = 0;
else
int_cmd_taupe3 = 1;
}

//Taupe
digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci
digitalWrite(cmd_taupe2, int_cmd_taupe2);
digitalWrite(cmd_taupe3, int_cmd_taupe3);

//LCD
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
if (digitalRead(cpt_taupe2) == 1 && int_cmd_taupe2 == 0)
{
pts++;
int_cmd_taupe2 = 1;
}
if (digitalRead(cpt_taupe3) == 1 && int_cmd_taupe3 == 0)
{
pts++;
int_cmd_taupe3 = 1;
}
}
</syntaxhighlight>

[[Catégorie:Enib2022]]

ENIB 2022 - groupe D : Tape-Taupe

2022-01-19T13:23:40Z

Titouan Melon : /* Construction de la taupe : */

==Photo de l'équipe==
(Ajouter une photo de nous.)

==Que fait ce projet ? ==

Des taupes montent et descendent.
Quand elles sortent de leur trou, il faut appuyer dessus pour les faire redescendre.
Quand le joueur arrive à appuyer sur la taupe avant qu'elle ne redescende, il marque des points qui sont affichés sur l'écran LCD et la taupe reste en bas.

==Liste des composants==

* 1 Arduino Mega
* Écran LCD (affichage du score)
* 7 Boutons poussoirs
* 7 solénoïdes
* Carte 2 relais (x4)
* Boitier en bois (découpe laser)
* Attache (bouton sur le solénoïde) (stylo 3D) (x7)
* Traverses (x3)
* Circlip (x7)
* Fils (x beaucoup)
* Breadboard

* Alimentation 12V
* Alimentation 5V (câble USB+PC)

==Construction==
Le dessus de la boite est percé, dans chaque trou, il y a une taupe.
==== Construction de la taupe : ====

[[Fichier:BoxPartie1.pdf|vignette]]
[[Fichier:BoxPartie2.pdf|vignette]]
[[Fichier:BoxPartie3.pdf|vignette]]

Mécanisme prévu à l'origine pour allonger la course de la taupe :
[[Fichier:Taupe originale.jpg|vignette|néant|Taupe origninale]]

[[Fichier:Une taupe.jpg|vignette|néant|Une taupe]]

==== Construction de la boite : ====
Il y a un trou pour chaque taupes dans le dessus de la boite, chaque rangés de taupes sont attachées sur une traverse.
Les traverses servent également à rigidifier la boite.

[[Fichier:Intérieur de la boite 2.jpg|vignette|néant]]

==Schéma électrique==
Un Arduino mage était nécessaire pour pouvoir gérer toutes les entrés en sorties du projet :
Pour chaque taupes (9 prévues 7 au final) :
* Commande du relais (qui commande le solénoïde)
* Entrée du bouton poussoir

Ecran LCD.

[[Fichier:Schéma.jpg|vignette|néant|Schéma]]

==Code==

Tout d'abord il faut tester les composants pour s'assurer qu'ils fonctionnent tous bien

===Bouton===

Ce code permet de verifier le fonctionnement des boutons
<syntaxhighlight lang=" C++">

int cpt_taupe1 = 22; //22 represente le pin ou sera branché le bouton

void setup() {
pinMode(cpt_taupe1, INPUT); //Cette ligne permet de passer le pin en mode entré
Serial.begin(9600); //Initialise le terminal
}

void loop() {
Serial.print("T1:");
Serial.println(digitalRead(cpt_taupe1)); //Ecris l'etat du pin du bouton (0 ou 1)
}
</syntaxhighlight>

===Solénoïde===

Ce code permettra d'activer/desactiver le selenoide 1s/1s

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53; //53 represente le pin ou sera branché le bouton
void setup() {
pinMode(cmd_taupe1, OUTPUT); //Cette ligne passe le pin en sortie
}

void loop() {
digitalWrite(cmd_taupe1, HIGH); //Active le relais
delay(1000); //attends 1s
digitalWrite(cmd_taupe1, LOW); //Desactive le relais
delay(1000); //attends 1s
}
</syntaxhighlight>

===LCD===

Pour voir toute les possibilité offerte par le LCD nous vous conseillons le site electronique amateur<ref>https://electroniqueamateur.blogspot.com/2019/01/ecran-oled-sh1106-i2c-et-arduino.html</ref>.

Ici on ne fait que écrire "vous avez: xx points" sur l'écran

<syntaxhighlight lang=" C++">
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

void setup() {
display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
}

void loop() {
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran
}
</syntaxhighlight>

===Taupe===

Ici le code rassemble un solenoide et un bouton pour faire une taupe

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53;
int int_cmd_taupe1 = 1;
int cpt_taupe1 = 22;

int pts = 0;

int start = 0;
int now = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);

pinMode(cpt_taupe1, INPUT);
Serial.begin(9600);
}

void loop() {
now = millis(); //On récupère le temps dans une variable
if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
if (int_cmd_taupe1 == 1) //Si la taupe est rentré elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;
}

digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
}
</syntaxhighlight>

===Prog final===

Aprés avoir vérifié et cablé il ne reste plus qu'a tout rassembler pour le code final

Ici il n'y a que 3 taupes mais vous pouvez en rajouter a votre guise et changer le texte sur l'ecran.

<syntaxhighlight lang=" C++">

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

int cmd_taupe1 = 53;
int cmd_taupe2 = 51;
int cmd_taupe3 = 49;

int int_cmd_taupe1 = 1;
int int_cmd_taupe2 = 1;
int int_cmd_taupe3 = 1;

int cpt_taupe1 = 22;
int cpt_taupe2 = 24;
int cpt_taupe3 = 26;

int pts = 0;

int start = 0;
int now = 0;

int random_int = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);
pinMode(cmd_taupe2, OUTPUT);
pinMode(cmd_taupe3, OUTPUT);

pinMode(cpt_taupe1, INPUT);
pinMode(cpt_taupe2, INPUT);
pinMode(cpt_taupe3, INPUT);
Serial.begin(9600);

display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
randomSeed(analogRead(0)); //Initialise le random par la lecture du bruit d'un pin analogique non branché
}

void loop() {
now = millis(); //On récupère le temps dans une variable

if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
random_int = random(1, 3); //On créer un nombre random entre 1 et le nombre de taupe (ici 3)
if (int_cmd_taupe1 == 1 and random_int == 1) //Si la taupe est rentré est que le random l'indique elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;

if (int_cmd_taupe2 == 1 and random_int == 2)
int_cmd_taupe2 = 0;
else
int_cmd_taupe2 = 1;

if (int_cmd_taupe3 == 1 and random_int == 3)
int_cmd_taupe3 = 0;
else
int_cmd_taupe3 = 1;
}

//Taupe
digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci
digitalWrite(cmd_taupe2, int_cmd_taupe2);
digitalWrite(cmd_taupe3, int_cmd_taupe3);

//LCD
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
if (digitalRead(cpt_taupe2) == 1 && int_cmd_taupe2 == 0)
{
pts++;
int_cmd_taupe2 = 1;
}
if (digitalRead(cpt_taupe3) == 1 && int_cmd_taupe3 == 0)
{
pts++;
int_cmd_taupe3 = 1;
}
}
</syntaxhighlight>

[[Catégorie:Enib2022]]

ENIB 2022 - groupe D : Tape-Taupe

2022-01-19T13:23:31Z

Titouan Melon : /* Construction de la taupe : */

==Photo de l'équipe==
(Ajouter une photo de nous.)

==Que fait ce projet ? ==

Des taupes montent et descendent.
Quand elles sortent de leur trou, il faut appuyer dessus pour les faire redescendre.
Quand le joueur arrive à appuyer sur la taupe avant qu'elle ne redescende, il marque des points qui sont affichés sur l'écran LCD et la taupe reste en bas.

==Liste des composants==

* 1 Arduino Mega
* Écran LCD (affichage du score)
* 7 Boutons poussoirs
* 7 solénoïdes
* Carte 2 relais (x4)
* Boitier en bois (découpe laser)
* Attache (bouton sur le solénoïde) (stylo 3D) (x7)
* Traverses (x3)
* Circlip (x7)
* Fils (x beaucoup)
* Breadboard

* Alimentation 12V
* Alimentation 5V (câble USB+PC)

==Construction==
Le dessus de la boite est percé, dans chaque trou, il y a une taupe.
==== Construction de la taupe : ====

[[Fichier:BoxPartie1.pdf|vignette|]]
[[Fichier:BoxPartie2.pdf|vignette|]]
[[Fichier:BoxPartie3.pdf|vignette|]]

Mécanisme prévu à l'origine pour allonger la course de la taupe :
[[Fichier:Taupe originale.jpg|vignette|néant|Taupe origninale]]

[[Fichier:Une taupe.jpg|vignette|néant|Une taupe]]

==== Construction de la boite : ====
Il y a un trou pour chaque taupes dans le dessus de la boite, chaque rangés de taupes sont attachées sur une traverse.
Les traverses servent également à rigidifier la boite.

[[Fichier:Intérieur de la boite 2.jpg|vignette|néant]]

==Schéma électrique==
Un Arduino mage était nécessaire pour pouvoir gérer toutes les entrés en sorties du projet :
Pour chaque taupes (9 prévues 7 au final) :
* Commande du relais (qui commande le solénoïde)
* Entrée du bouton poussoir

Ecran LCD.

[[Fichier:Schéma.jpg|vignette|néant|Schéma]]

==Code==

Tout d'abord il faut tester les composants pour s'assurer qu'ils fonctionnent tous bien

===Bouton===

Ce code permet de verifier le fonctionnement des boutons
<syntaxhighlight lang=" C++">

int cpt_taupe1 = 22; //22 represente le pin ou sera branché le bouton

void setup() {
pinMode(cpt_taupe1, INPUT); //Cette ligne permet de passer le pin en mode entré
Serial.begin(9600); //Initialise le terminal
}

void loop() {
Serial.print("T1:");
Serial.println(digitalRead(cpt_taupe1)); //Ecris l'etat du pin du bouton (0 ou 1)
}
</syntaxhighlight>

===Solénoïde===

Ce code permettra d'activer/desactiver le selenoide 1s/1s

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53; //53 represente le pin ou sera branché le bouton
void setup() {
pinMode(cmd_taupe1, OUTPUT); //Cette ligne passe le pin en sortie
}

void loop() {
digitalWrite(cmd_taupe1, HIGH); //Active le relais
delay(1000); //attends 1s
digitalWrite(cmd_taupe1, LOW); //Desactive le relais
delay(1000); //attends 1s
}
</syntaxhighlight>

===LCD===

Pour voir toute les possibilité offerte par le LCD nous vous conseillons le site electronique amateur<ref>https://electroniqueamateur.blogspot.com/2019/01/ecran-oled-sh1106-i2c-et-arduino.html</ref>.

Ici on ne fait que écrire "vous avez: xx points" sur l'écran

<syntaxhighlight lang=" C++">
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

void setup() {
display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
}

void loop() {
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran
}
</syntaxhighlight>

===Taupe===

Ici le code rassemble un solenoide et un bouton pour faire une taupe

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53;
int int_cmd_taupe1 = 1;
int cpt_taupe1 = 22;

int pts = 0;

int start = 0;
int now = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);

pinMode(cpt_taupe1, INPUT);
Serial.begin(9600);
}

void loop() {
now = millis(); //On récupère le temps dans une variable
if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
if (int_cmd_taupe1 == 1) //Si la taupe est rentré elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;
}

digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
}
</syntaxhighlight>

===Prog final===

Aprés avoir vérifié et cablé il ne reste plus qu'a tout rassembler pour le code final

Ici il n'y a que 3 taupes mais vous pouvez en rajouter a votre guise et changer le texte sur l'ecran.

<syntaxhighlight lang=" C++">

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

int cmd_taupe1 = 53;
int cmd_taupe2 = 51;
int cmd_taupe3 = 49;

int int_cmd_taupe1 = 1;
int int_cmd_taupe2 = 1;
int int_cmd_taupe3 = 1;

int cpt_taupe1 = 22;
int cpt_taupe2 = 24;
int cpt_taupe3 = 26;

int pts = 0;

int start = 0;
int now = 0;

int random_int = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);
pinMode(cmd_taupe2, OUTPUT);
pinMode(cmd_taupe3, OUTPUT);

pinMode(cpt_taupe1, INPUT);
pinMode(cpt_taupe2, INPUT);
pinMode(cpt_taupe3, INPUT);
Serial.begin(9600);

display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
randomSeed(analogRead(0)); //Initialise le random par la lecture du bruit d'un pin analogique non branché
}

void loop() {
now = millis(); //On récupère le temps dans une variable

if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
random_int = random(1, 3); //On créer un nombre random entre 1 et le nombre de taupe (ici 3)
if (int_cmd_taupe1 == 1 and random_int == 1) //Si la taupe est rentré est que le random l'indique elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;

if (int_cmd_taupe2 == 1 and random_int == 2)
int_cmd_taupe2 = 0;
else
int_cmd_taupe2 = 1;

if (int_cmd_taupe3 == 1 and random_int == 3)
int_cmd_taupe3 = 0;
else
int_cmd_taupe3 = 1;
}

//Taupe
digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci
digitalWrite(cmd_taupe2, int_cmd_taupe2);
digitalWrite(cmd_taupe3, int_cmd_taupe3);

//LCD
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
if (digitalRead(cpt_taupe2) == 1 && int_cmd_taupe2 == 0)
{
pts++;
int_cmd_taupe2 = 1;
}
if (digitalRead(cpt_taupe3) == 1 && int_cmd_taupe3 == 0)
{
pts++;
int_cmd_taupe3 = 1;
}
}
</syntaxhighlight>

[[Catégorie:Enib2022]]

ENIB 2022 - groupe D : Tape-Taupe

2022-01-19T13:22:47Z

Titouan Melon : /* Construction */

==Photo de l'équipe==
(Ajouter une photo de nous.)

==Que fait ce projet ? ==

Des taupes montent et descendent.
Quand elles sortent de leur trou, il faut appuyer dessus pour les faire redescendre.
Quand le joueur arrive à appuyer sur la taupe avant qu'elle ne redescende, il marque des points qui sont affichés sur l'écran LCD et la taupe reste en bas.

==Liste des composants==

* 1 Arduino Mega
* Écran LCD (affichage du score)
* 7 Boutons poussoirs
* 7 solénoïdes
* Carte 2 relais (x4)
* Boitier en bois (découpe laser)
* Attache (bouton sur le solénoïde) (stylo 3D) (x7)
* Traverses (x3)
* Circlip (x7)
* Fils (x beaucoup)
* Breadboard

* Alimentation 12V
* Alimentation 5V (câble USB+PC)

==Construction==
Le dessus de la boite est percé, dans chaque trou, il y a une taupe.
==== Construction de la taupe : ====

[[Fichier:BoxPartie1.pdf|vignette|néant|Taupe origninale]]
[[Fichier:BoxPartie2.pdf|vignette|néant|Taupe origninale]]
[[Fichier:BoxPartie3.pdf|vignette|néant|Taupe origninale]]

Mécanisme prévu à l'origine pour allonger la course de la taupe :
[[Fichier:Taupe originale.jpg|vignette|néant|Taupe origninale]]

[[Fichier:Une taupe.jpg|vignette|néant|Une taupe]]

==== Construction de la boite : ====
Il y a un trou pour chaque taupes dans le dessus de la boite, chaque rangés de taupes sont attachées sur une traverse.
Les traverses servent également à rigidifier la boite.

[[Fichier:Intérieur de la boite 2.jpg|vignette|néant]]

==Schéma électrique==
Un Arduino mage était nécessaire pour pouvoir gérer toutes les entrés en sorties du projet :
Pour chaque taupes (9 prévues 7 au final) :
* Commande du relais (qui commande le solénoïde)
* Entrée du bouton poussoir

Ecran LCD.

[[Fichier:Schéma.jpg|vignette|néant|Schéma]]

==Code==

Tout d'abord il faut tester les composants pour s'assurer qu'ils fonctionnent tous bien

===Bouton===

Ce code permet de verifier le fonctionnement des boutons
<syntaxhighlight lang=" C++">

int cpt_taupe1 = 22; //22 represente le pin ou sera branché le bouton

void setup() {
pinMode(cpt_taupe1, INPUT); //Cette ligne permet de passer le pin en mode entré
Serial.begin(9600); //Initialise le terminal
}

void loop() {
Serial.print("T1:");
Serial.println(digitalRead(cpt_taupe1)); //Ecris l'etat du pin du bouton (0 ou 1)
}
</syntaxhighlight>

===Solénoïde===

Ce code permettra d'activer/desactiver le selenoide 1s/1s

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53; //53 represente le pin ou sera branché le bouton
void setup() {
pinMode(cmd_taupe1, OUTPUT); //Cette ligne passe le pin en sortie
}

void loop() {
digitalWrite(cmd_taupe1, HIGH); //Active le relais
delay(1000); //attends 1s
digitalWrite(cmd_taupe1, LOW); //Desactive le relais
delay(1000); //attends 1s
}
</syntaxhighlight>

===LCD===

Pour voir toute les possibilité offerte par le LCD nous vous conseillons le site electronique amateur<ref>https://electroniqueamateur.blogspot.com/2019/01/ecran-oled-sh1106-i2c-et-arduino.html</ref>.

Ici on ne fait que écrire "vous avez: xx points" sur l'écran

<syntaxhighlight lang=" C++">
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

void setup() {
display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
}

void loop() {
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran
}
</syntaxhighlight>

===Taupe===

Ici le code rassemble un solenoide et un bouton pour faire une taupe

<syntaxhighlight lang=" C++">

int cmd_taupe1 = 53;
int int_cmd_taupe1 = 1;
int cpt_taupe1 = 22;

int pts = 0;

int start = 0;
int now = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);

pinMode(cpt_taupe1, INPUT);
Serial.begin(9600);
}

void loop() {
now = millis(); //On récupère le temps dans une variable
if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
if (int_cmd_taupe1 == 1) //Si la taupe est rentré elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;
}

digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
}
</syntaxhighlight>

===Prog final===

Aprés avoir vérifié et cablé il ne reste plus qu'a tout rassembler pour le code final

Ici il n'y a que 3 taupes mais vous pouvez en rajouter a votre guise et changer le texte sur l'ecran.

<syntaxhighlight lang=" C++">

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SH1106.h>

Adafruit_SH1106 display(23);

int cmd_taupe1 = 53;
int cmd_taupe2 = 51;
int cmd_taupe3 = 49;

int int_cmd_taupe1 = 1;
int int_cmd_taupe2 = 1;
int int_cmd_taupe3 = 1;

int cpt_taupe1 = 22;
int cpt_taupe2 = 24;
int cpt_taupe3 = 26;

int pts = 0;

int start = 0;
int now = 0;

int random_int = 0;

void setup() {
pinMode(cmd_taupe1, OUTPUT);
pinMode(cmd_taupe2, OUTPUT);
pinMode(cmd_taupe3, OUTPUT);

pinMode(cpt_taupe1, INPUT);
pinMode(cpt_taupe2, INPUT);
pinMode(cpt_taupe3, INPUT);
Serial.begin(9600);

display.begin(); // initialisation de l'afficheur
display.clearDisplay(); // ça efface à la fois le buffer et l'écran
randomSeed(analogRead(0)); //Initialise le random par la lecture du bruit d'un pin analogique non branché
}

void loop() {
now = millis(); //On récupère le temps dans une variable

if (now-start > 1000) //Si il s'est écoulé plus de 1s
{
start = millis(); //On renitialise le temps de départ du timer
random_int = random(1, 3); //On créer un nombre random entre 1 et le nombre de taupe (ici 3)
if (int_cmd_taupe1 == 1 and random_int == 1) //Si la taupe est rentré est que le random l'indique elle sort
int_cmd_taupe1 = 0;
else //sinon elle rentre
int_cmd_taupe1 = 1;

if (int_cmd_taupe2 == 1 and random_int == 2)
int_cmd_taupe2 = 0;
else
int_cmd_taupe2 = 1;

if (int_cmd_taupe3 == 1 and random_int == 3)
int_cmd_taupe3 = 0;
else
int_cmd_taupe3 = 1;
}

//Taupe
digitalWrite(cmd_taupe1, int_cmd_taupe1); //On ecrit sur les pin des selenoide les valeurs de commande de ceux ci
digitalWrite(cmd_taupe2, int_cmd_taupe2);
digitalWrite(cmd_taupe3, int_cmd_taupe3);

//LCD
display.setCursor(30, 15); // coordonnées du point de départ du texte
display.setTextColor(WHITE);
display.setTextSize(1); // taille par défaut
display.println("Vous avez :");
display.setCursor(50, 35); // coordonnées du point de départ du texte
display.println(" points");
display.setCursor(30, 35); // coordonnées du point de départ du texte
display.print(pts);
display.display(); //Affiche l'ecran
display.clearDisplay(); //Efface l'ecran

//Capteur
if (digitalRead(cpt_taupe1) == 1 && int_cmd_taupe1 == 0) //Si la taupe est relevé est que le bouton est appuyé on gagne 1 points et la taupe se baisse
{
pts++;
int_cmd_taupe1 = 1;
}
if (digitalRead(cpt_taupe2) == 1 && int_cmd_taupe2 == 0)
{
pts++;
int_cmd_taupe2 = 1;
}
if (digitalRead(cpt_taupe3) == 1 && int_cmd_taupe3 == 0)
{
pts++;
int_cmd_taupe3 = 1;
}
}
</syntaxhighlight>

[[Catégorie:Enib2022]]

Fichier:BoxPartie3.pdf

2022-01-19T13:20:52Z

Titouan Melon :

Fichier:BoxPartie2.pdf

2022-01-19T13:20:31Z

Titouan Melon :

2022-01-18T17:25:56Z

Titouan Melon : /* LCD */