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

ENIB 2022 - groupe C : flipper

2022-01-19T11:12:25Z

Erwann : /* photo de l'équipe */

==photo de l'équipe==

==Que fait ce projet ? ==
L'objectif est de recréer un flipper taille miniature.

==Liste des composants==

* carte arduino nano
* 2 gachettes de flipper (voir le fichier stl puis les imprimer)
* planches en bois à couper aux bonnes dimensions
* x capteurs piezo avec résistance d'un MegΩ
* 4 élastiques
* une bille
* 1 bouchon en liège
* une tige en bois (dans laquelle on pourra embrocher des bouchons en lièges)

[[media:Haut gachette.stl|haut des gachettes du flipper]]

==Fichiers à avoir==
* [[Fichier:Haut gachette.stl]] à imprimer en 3D deux fois
* [[Fichier:Bas.stl]] à imprimer en 3D deux fois également

==Comment faire==
[[Image:Flipper2022ENIBcabalage.png]]

==Sources==
* gestion de la mémoire arduino : https://zestedesavoir.com/tutoriels/374/gestion-de-la-memoire-sur-arduino/

==Code==
<pre>
#include "EEPROM.h"
#include <Wire.h>
#include "rgb_lcd.h"

rgb_lcd lcd;
//branchement ecran lcd à Arduino Nano : GND relié à la masse VCC relié au 5V SDA relié à A4 SCL relié à A5
const int colorR = 255;
const int colorG = 255;
const int colorB = 255;

int currentState;
const int BUTTON_PIN = 6;
int startgame = 0;
int endgame = 0;

//branchement capteur piezo : brancher en parallèle une résistance et le capteur piezo, les broches du capteur piezo : Une broche sur GND l'autre broche sur A0
// Variable pour désigner quelle pin est utilisée pour le capteur
int capteurPiezo = A0; // pin Analog 0
// Variable pour contenir la valeur du capteur
int valeurPiezo ;
int score;
int highscore;

void setup() {
// Établit la connexion série à 9600 bauds
Serial.begin(9600);
pinMode(BUTTON_PIN, INPUT_PULLUP);
highscore = EEPROM.read(600);
//Serial.println("Highscore");Serial.println(highscore);

// set up the LCD's number of columns and rows:
lcd.begin(16, 2);

lcd.setRGB(colorR, colorG, colorB);

// Print a message to the LCD.
lcd.clear();
lcd.setCursor(0,0);

}

void loop() {

currentState = digitalRead(BUTTON_PIN);
//Serial.println("currentState");Serial.println(currentState);

if(currentState==0)
{
delay(100);
if(startgame==0)
{startgame=1;
score=0;
endgame=0;}
else
{startgame=0;
endgame=1;}
}

if (startgame==0)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Highscore : ");lcd.print(highscore);
if(score!=0)
{
lcd.setCursor(0,1);
lcd.print("Your score : ");lcd.print(score);
}
}

if (startgame==1)
{

// Lit la pin du capteur et l'assigne à la variable valeurPiezo
valeurPiezo = analogRead(capteurPiezo);
// Affiche au moniteur série la valeur de valeurPiezo
if (valeurPiezo >= 1 )
{
score+=1;
//Serial.println("score");Serial.println(score);
}

// Laisse un court délai afin que l'utilisateur puisse lire les valeurs correctement
delay(50);

if(score>highscore)
{EEPROM.write(600,score);
}
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Highscore : ");lcd.print(highscore);
lcd.setCursor(0,1);
lcd.print("Your score : ");lcd.print(score);
}

}

</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe C : flipper

2022-01-19T11:12:03Z

Erwann : /* Comment faire */

==photo de l'équipe==
[[Fichier:Photoenib2018.jpg|600px]]

==Que fait ce projet ? ==
L'objectif est de recréer un flipper taille miniature.

==Liste des composants==

* carte arduino nano
* 2 gachettes de flipper (voir le fichier stl puis les imprimer)
* planches en bois à couper aux bonnes dimensions
* x capteurs piezo avec résistance d'un MegΩ
* 4 élastiques
* une bille
* 1 bouchon en liège
* une tige en bois (dans laquelle on pourra embrocher des bouchons en lièges)

[[media:Haut gachette.stl|haut des gachettes du flipper]]

==Fichiers à avoir==
* [[Fichier:Haut gachette.stl]] à imprimer en 3D deux fois
* [[Fichier:Bas.stl]] à imprimer en 3D deux fois également

==Comment faire==
[[Image:Flipper2022ENIBcabalage.png]]

==Sources==
* gestion de la mémoire arduino : https://zestedesavoir.com/tutoriels/374/gestion-de-la-memoire-sur-arduino/

==Code==
<pre>
#include "EEPROM.h"
#include <Wire.h>
#include "rgb_lcd.h"

rgb_lcd lcd;
//branchement ecran lcd à Arduino Nano : GND relié à la masse VCC relié au 5V SDA relié à A4 SCL relié à A5
const int colorR = 255;
const int colorG = 255;
const int colorB = 255;

int currentState;
const int BUTTON_PIN = 6;
int startgame = 0;
int endgame = 0;

//branchement capteur piezo : brancher en parallèle une résistance et le capteur piezo, les broches du capteur piezo : Une broche sur GND l'autre broche sur A0
// Variable pour désigner quelle pin est utilisée pour le capteur
int capteurPiezo = A0; // pin Analog 0
// Variable pour contenir la valeur du capteur
int valeurPiezo ;
int score;
int highscore;

void setup() {
// Établit la connexion série à 9600 bauds
Serial.begin(9600);
pinMode(BUTTON_PIN, INPUT_PULLUP);
highscore = EEPROM.read(600);
//Serial.println("Highscore");Serial.println(highscore);

// set up the LCD's number of columns and rows:
lcd.begin(16, 2);

lcd.setRGB(colorR, colorG, colorB);

// Print a message to the LCD.
lcd.clear();
lcd.setCursor(0,0);

}

void loop() {

currentState = digitalRead(BUTTON_PIN);
//Serial.println("currentState");Serial.println(currentState);

if(currentState==0)
{
delay(100);
if(startgame==0)
{startgame=1;
score=0;
endgame=0;}
else
{startgame=0;
endgame=1;}
}

if (startgame==0)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Highscore : ");lcd.print(highscore);
if(score!=0)
{
lcd.setCursor(0,1);
lcd.print("Your score : ");lcd.print(score);
}
}

if (startgame==1)
{

// Lit la pin du capteur et l'assigne à la variable valeurPiezo
valeurPiezo = analogRead(capteurPiezo);
// Affiche au moniteur série la valeur de valeurPiezo
if (valeurPiezo >= 1 )
{
score+=1;
//Serial.println("score");Serial.println(score);
}

// Laisse un court délai afin que l'utilisateur puisse lire les valeurs correctement
delay(50);

if(score>highscore)
{EEPROM.write(600,score);
}
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Highscore : ");lcd.print(highscore);
lcd.setCursor(0,1);
lcd.print("Your score : ");lcd.print(score);
}

}

</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe C : flipper

2022-01-19T11:11:05Z

Erwann : /* Comment faire */

==photo de l'équipe==
[[Fichier:Photoenib2018.jpg|600px]]

==Que fait ce projet ? ==
L'objectif est de recréer un flipper taille miniature.

==Liste des composants==

* carte arduino nano
* 2 gachettes de flipper (voir le fichier stl puis les imprimer)
* planches en bois à couper aux bonnes dimensions
* x capteurs piezo avec résistance d'un MegΩ
* 4 élastiques
* une bille
* 1 bouchon en liège
* une tige en bois (dans laquelle on pourra embrocher des bouchons en lièges)

[[media:Haut gachette.stl|vignette|haut des gachettes du flipper]]

==Fichiers à avoir==
* [[Fichier:Haut gachette.stl]] à imprimer en 3D deux fois
* [[Fichier:Bas.stl]] à imprimer en 3D deux fois également

==Comment faire==
[[Image:Flipper2022ENIBcabalage.png|vignette]]

==Sources==
* gestion de la mémoire arduino : https://zestedesavoir.com/tutoriels/374/gestion-de-la-memoire-sur-arduino/

==Code==
<pre>
#include "EEPROM.h"
#include <Wire.h>
#include "rgb_lcd.h"

rgb_lcd lcd;
//branchement ecran lcd à Arduino Nano : GND relié à la masse VCC relié au 5V SDA relié à A4 SCL relié à A5
const int colorR = 255;
const int colorG = 255;
const int colorB = 255;

int currentState;
const int BUTTON_PIN = 6;
int startgame = 0;
int endgame = 0;

//branchement capteur piezo : brancher en parallèle une résistance et le capteur piezo, les broches du capteur piezo : Une broche sur GND l'autre broche sur A0
// Variable pour désigner quelle pin est utilisée pour le capteur
int capteurPiezo = A0; // pin Analog 0
// Variable pour contenir la valeur du capteur
int valeurPiezo ;
int score;
int highscore;

void setup() {
// Établit la connexion série à 9600 bauds
Serial.begin(9600);
pinMode(BUTTON_PIN, INPUT_PULLUP);
highscore = EEPROM.read(600);
//Serial.println("Highscore");Serial.println(highscore);

// set up the LCD's number of columns and rows:
lcd.begin(16, 2);

lcd.setRGB(colorR, colorG, colorB);

// Print a message to the LCD.
lcd.clear();
lcd.setCursor(0,0);

}

void loop() {

currentState = digitalRead(BUTTON_PIN);
//Serial.println("currentState");Serial.println(currentState);

if(currentState==0)
{
delay(100);
if(startgame==0)
{startgame=1;
score=0;
endgame=0;}
else
{startgame=0;
endgame=1;}
}

if (startgame==0)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Highscore : ");lcd.print(highscore);
if(score!=0)
{
lcd.setCursor(0,1);
lcd.print("Your score : ");lcd.print(score);
}
}

if (startgame==1)
{

// Lit la pin du capteur et l'assigne à la variable valeurPiezo
valeurPiezo = analogRead(capteurPiezo);
// Affiche au moniteur série la valeur de valeurPiezo
if (valeurPiezo >= 1 )
{
score+=1;
//Serial.println("score");Serial.println(score);
}

// Laisse un court délai afin que l'utilisateur puisse lire les valeurs correctement
delay(50);

if(score>highscore)
{EEPROM.write(600,score);
}
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Highscore : ");lcd.print(highscore);
lcd.setCursor(0,1);
lcd.print("Your score : ");lcd.print(score);
}

}

</pre>

==Catégories==

[[Catégorie:Enib2022]]

Fichier:Flipper2022ENIBcabalage.png

2022-01-19T11:10:19Z

Erwann :

ENIB 2022 - groupe C : flipper

2022-01-19T11:04:17Z

Erwann : /* Comment faire */

==photo de l'équipe==
[[Fichier:Photoenib2018.jpg|600px]]

==Que fait ce projet ? ==
L'objectif est de recréer un flipper taille miniature.

==Liste des composants==

* carte arduino nano
* 2 gachettes de flipper (voir le fichier stl puis les imprimer)
* planches en bois à couper aux bonnes dimensions
* x capteurs piezo avec résistance d'un MegΩ
* 4 élastiques
* une bille
* 1 bouchon en liège
* une tige en bois (dans laquelle on pourra embrocher des bouchons en lièges)

[[media:Haut gachette.stl|vignette|haut des gachettes du flipper]]

==Fichiers à avoir==
* [[Fichier:Haut gachette.stl]] à imprimer en 3D deux fois
* [[Fichier:Bas.stl]] à imprimer en 3D deux fois également

==Comment faire==
[[Fichier:ENIB2022Flippercablage.png|vignette]]

==Sources==
* gestion de la mémoire arduino : https://zestedesavoir.com/tutoriels/374/gestion-de-la-memoire-sur-arduino/

==Code==
<pre>
#include "EEPROM.h"
#include <Wire.h>
#include "rgb_lcd.h"

rgb_lcd lcd;
//branchement ecran lcd à Arduino Nano : GND relié à la masse VCC relié au 5V SDA relié à A4 SCL relié à A5
const int colorR = 255;
const int colorG = 255;
const int colorB = 255;

int currentState;
const int BUTTON_PIN = 6;
int startgame = 0;
int endgame = 0;

//branchement capteur piezo : brancher en parallèle une résistance et le capteur piezo, les broches du capteur piezo : Une broche sur GND l'autre broche sur A0
// Variable pour désigner quelle pin est utilisée pour le capteur
int capteurPiezo = A0; // pin Analog 0
// Variable pour contenir la valeur du capteur
int valeurPiezo ;
int score;
int highscore;

void setup() {
// Établit la connexion série à 9600 bauds
Serial.begin(9600);
pinMode(BUTTON_PIN, INPUT_PULLUP);
highscore = EEPROM.read(600);
//Serial.println("Highscore");Serial.println(highscore);

// set up the LCD's number of columns and rows:
lcd.begin(16, 2);

lcd.setRGB(colorR, colorG, colorB);

// Print a message to the LCD.
lcd.clear();
lcd.setCursor(0,0);

}

void loop() {

currentState = digitalRead(BUTTON_PIN);
//Serial.println("currentState");Serial.println(currentState);

if(currentState==0)
{
delay(100);
if(startgame==0)
{startgame=1;
score=0;
endgame=0;}
else
{startgame=0;
endgame=1;}
}

if (startgame==0)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Highscore : ");lcd.print(highscore);
if(score!=0)
{
lcd.setCursor(0,1);
lcd.print("Your score : ");lcd.print(score);
}
}

if (startgame==1)
{

// Lit la pin du capteur et l'assigne à la variable valeurPiezo
valeurPiezo = analogRead(capteurPiezo);
// Affiche au moniteur série la valeur de valeurPiezo
if (valeurPiezo >= 1 )
{
score+=1;
//Serial.println("score");Serial.println(score);
}

// Laisse un court délai afin que l'utilisateur puisse lire les valeurs correctement
delay(50);

if(score>highscore)
{EEPROM.write(600,score);
}
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Highscore : ");lcd.print(highscore);
lcd.setCursor(0,1);
lcd.print("Your score : ");lcd.print(score);
}

}

</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe C : flipper

2022-01-19T11:03:19Z

Erwann : /* Comment faire */

==photo de l'équipe==
[[Fichier:Photoenib2018.jpg|600px]]

==Que fait ce projet ? ==
L'objectif est de recréer un flipper taille miniature.

==Liste des composants==

* carte arduino nano
* 2 gachettes de flipper (voir le fichier stl puis les imprimer)
* planches en bois à couper aux bonnes dimensions
* x capteurs piezo avec résistance d'un MegΩ
* 4 élastiques
* une bille
* 1 bouchon en liège
* une tige en bois (dans laquelle on pourra embrocher des bouchons en lièges)

[[media:Haut gachette.stl|vignette|haut des gachettes du flipper]]

==Fichiers à avoir==
* [[Fichier:Haut gachette.stl]] à imprimer en 3D deux fois
* [[Fichier:Bas.stl]] à imprimer en 3D deux fois également

==Comment faire==
[[image:ENIB2022Flippercablage.png]]

==Sources==
* gestion de la mémoire arduino : https://zestedesavoir.com/tutoriels/374/gestion-de-la-memoire-sur-arduino/

==Code==
<pre>
#include "EEPROM.h"
#include <Wire.h>
#include "rgb_lcd.h"

rgb_lcd lcd;
//branchement ecran lcd à Arduino Nano : GND relié à la masse VCC relié au 5V SDA relié à A4 SCL relié à A5
const int colorR = 255;
const int colorG = 255;
const int colorB = 255;

int currentState;
const int BUTTON_PIN = 6;
int startgame = 0;
int endgame = 0;

//branchement capteur piezo : brancher en parallèle une résistance et le capteur piezo, les broches du capteur piezo : Une broche sur GND l'autre broche sur A0
// Variable pour désigner quelle pin est utilisée pour le capteur
int capteurPiezo = A0; // pin Analog 0
// Variable pour contenir la valeur du capteur
int valeurPiezo ;
int score;
int highscore;

void setup() {
// Établit la connexion série à 9600 bauds
Serial.begin(9600);
pinMode(BUTTON_PIN, INPUT_PULLUP);
highscore = EEPROM.read(600);
//Serial.println("Highscore");Serial.println(highscore);

// set up the LCD's number of columns and rows:
lcd.begin(16, 2);

lcd.setRGB(colorR, colorG, colorB);

// Print a message to the LCD.
lcd.clear();
lcd.setCursor(0,0);

}

void loop() {

currentState = digitalRead(BUTTON_PIN);
//Serial.println("currentState");Serial.println(currentState);

if(currentState==0)
{
delay(100);
if(startgame==0)
{startgame=1;
score=0;
endgame=0;}
else
{startgame=0;
endgame=1;}
}

if (startgame==0)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Highscore : ");lcd.print(highscore);
if(score!=0)
{
lcd.setCursor(0,1);
lcd.print("Your score : ");lcd.print(score);
}
}

if (startgame==1)
{

// Lit la pin du capteur et l'assigne à la variable valeurPiezo
valeurPiezo = analogRead(capteurPiezo);
// Affiche au moniteur série la valeur de valeurPiezo
if (valeurPiezo >= 1 )
{
score+=1;
//Serial.println("score");Serial.println(score);
}

// Laisse un court délai afin que l'utilisateur puisse lire les valeurs correctement
delay(50);

if(score>highscore)
{EEPROM.write(600,score);
}
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Highscore : ");lcd.print(highscore);
lcd.setCursor(0,1);
lcd.print("Your score : ");lcd.print(score);
}

}

</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe C : flipper

2022-01-17T15:19:05Z

Erwann : /* Code */

==photo de l'équipe==
[[Fichier:Photoenib2018.jpg|600px]]

==Que fait ce projet ? ==
L'objectif est de recréer un flipper taille miniature.

==Liste des composants==

* carte arduino nano
* 2 gachettes de flipper (voir le fichier stl puis les imprimer)
* planches en bois à couper aux bonnes dimensions
* x capteurs piezo avec résistance d'un MegΩ
* 4 élastiques
* une bille
* 1 bouchon en liège
* une tige en bois (dans laquelle on pourra embrocher des bouchons en lièges)

[[media:Haut gachette.stl|vignette|haut des gachettes du flipper]]

==Fichiers à avoir==
* [[Fichier:Haut gachette.stl]] à imprimer en 3D deux fois
* [[Fichier:Bas.stl]] à imprimer en 3D deux fois également

==Comment faire==

==Sources==
* gestion de la mémoire arduino : https://zestedesavoir.com/tutoriels/374/gestion-de-la-memoire-sur-arduino/

==Code==
<pre>
#include "EEPROM.h"
#include <Wire.h>
#include "rgb_lcd.h"

rgb_lcd lcd;
//branchement ecran lcd à Arduino Nano : GND relié à la masse VCC relié au 5V SDA relié à A4 SCL relié à A5
const int colorR = 255;
const int colorG = 255;
const int colorB = 255;

int currentState;
const int BUTTON_PIN = 6;
int startgame = 0;
int endgame = 0;

//branchement capteur piezo : brancher en parallèle une résistance et le capteur piezo, les broches du capteur piezo : Une broche sur GND l'autre broche sur A0
// Variable pour désigner quelle pin est utilisée pour le capteur
int capteurPiezo = A0; // pin Analog 0
// Variable pour contenir la valeur du capteur
int valeurPiezo ;
int score;
int highscore;

void setup() {
// Établit la connexion série à 9600 bauds
Serial.begin(9600);
pinMode(BUTTON_PIN, INPUT_PULLUP);
highscore = EEPROM.read(600);
//Serial.println("Highscore");Serial.println(highscore);

// set up the LCD's number of columns and rows:
lcd.begin(16, 2);

lcd.setRGB(colorR, colorG, colorB);

// Print a message to the LCD.
lcd.clear();
lcd.setCursor(0,0);

}

void loop() {

currentState = digitalRead(BUTTON_PIN);
//Serial.println("currentState");Serial.println(currentState);

if(currentState==0)
{
delay(100);
if(startgame==0)
{startgame=1;
score=0;
endgame=0;}
else
{startgame=0;
endgame=1;}
}

if (startgame==0)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Highscore : ");lcd.print(highscore);
if(score!=0)
{
lcd.setCursor(0,1);
lcd.print("Your score : ");lcd.print(score);
}
}

if (startgame==1)
{

// Lit la pin du capteur et l'assigne à la variable valeurPiezo
valeurPiezo = analogRead(capteurPiezo);
// Affiche au moniteur série la valeur de valeurPiezo
if (valeurPiezo >= 1 )
{
score+=1;
//Serial.println("score");Serial.println(score);
}

// Laisse un court délai afin que l'utilisateur puisse lire les valeurs correctement
delay(50);

if(score>highscore)
{EEPROM.write(600,score);
}
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Highscore : ");lcd.print(highscore);
lcd.setCursor(0,1);
lcd.print("Your score : ");lcd.print(score);
}

}

</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe C : flipper

2022-01-17T15:18:31Z

Erwann :

==photo de l'équipe==
[[Fichier:Photoenib2018.jpg|600px]]

==Que fait ce projet ? ==
L'objectif est de recréer un flipper taille miniature.

==Liste des composants==

* carte arduino nano
* 2 gachettes de flipper (voir le fichier stl puis les imprimer)
* planches en bois à couper aux bonnes dimensions
* x capteurs piezo avec résistance d'un MegΩ
* 4 élastiques
* une bille
* 1 bouchon en liège
* une tige en bois (dans laquelle on pourra embrocher des bouchons en lièges)

[[media:Haut gachette.stl|vignette|haut des gachettes du flipper]]

==Fichiers à avoir==
* [[Fichier:Haut gachette.stl]] à imprimer en 3D deux fois
* [[Fichier:Bas.stl]] à imprimer en 3D deux fois également

==Comment faire==

==Sources==
* gestion de la mémoire arduino : https://zestedesavoir.com/tutoriels/374/gestion-de-la-memoire-sur-arduino/

==Code==
<pre>
////////////////////////////////
// Test //
// capteur de pression Piezo //
////////////////////////////////
/*
* vendredi 30 juillet 2021
* D1 mini
* code inspiré de Arduino FlossManual - https://fr.flossmanuals.net/arduino/_draft/_v/1.0/perroquet/
* matériel
* - D1 mini
* - breadboard
* - jumper
* - piezo
* - résistance 10 Mégaohms
*
* * BROCHAGE
_________________
/ D1 mini \
- |[ ]RST TX[ ]| -
Résistance - Capteur Piezo - |[X]A0 -GPIO RX[ ]| -
|[ ]D0-16 5-D1[ ]| -
|[ ]D5-14 4-D2[ ]| -
- |[ ]D6-12 0-D3[ ]| -
- |[ ]D7-13 2-D4[ ]| LED_BUILTIN
- |[ ]D8-15 GND[X]| - GND - Capteur Piezo - resistance
- |[ ]3V3 . 5V[X]| - ruban de Led
| +---+ |
|_______|USB|_______|

* Antony Le Goïc-Auffret
*
*/

// Variable pour désigner quelle pin est utilisée pour le capteur
int capteurPiezo = A0; // pin Analog 0
// Variable pour contenir la valeur du capteur
int valeurPiezo ;

void setup() {
// Établit la connexion série à 9600 bauds
Serial.begin(9600);
}

void loop() {
// Lit la pin du capteur et l'assigne à la variable valeurPiezo
valeurPiezo = analogRead(capteurPiezo);
// Affiche au moniteur série la valeur de valeurPiezo
Serial.println(valeurPiezo);
// Laisse un court délai afin que l'utilisateur puisse lire les valeurs correctement
delay(100);
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe C : flipper

2022-01-17T15:16:00Z

Erwann : /* Code */

==photo de l'équipe==
[[Fichier:Photoenib2018.jpg|600px]]

==Que fait ce projet ? ==
L'objectif est de recréer un flipper taille miniature.

==Liste des composants==

* carte arduino nano
* 2 gachettes de flipper (voir le fichier stl puis les imprimer)
* planches en bois à couper aux bonnes dimensions
* x capteurs piezo avec résistance d'un MegΩ
* 4 élastiques
* une bille
* 1 bouchon en liège
* une tige en bois (dans laquelle on pourra embrocher des bouchons en lièges)

[[media:Haut gachette.stl|vignette|haut des gachettes du flipper]]

==Fichiers à avoir==
* [[Fichier:Haut gachette.stl]] à imprimer en 3D deux fois
* [[Fichier:Bas.stl]] à imprimer en 3D deux fois également

==Sources==
* gestion de la mémoire arduino : https://zestedesavoir.com/tutoriels/374/gestion-de-la-memoire-sur-arduino/

#include "EEPROM.h"
#include <Wire.h>
#include "rgb_lcd.h"

rgb_lcd lcd;
//branchement ecran lcd à Arduino Nano : GND relié à la masse VCC relié au 5V SDA relié à A4 SCL relié à A5
const int colorR = 255;
const int colorG = 255;
const int colorB = 255;

int currentState;
const int BUTTON_PIN = 6;
int startgame = 0;
int endgame = 0;

//branchement capteur piezo : brancher en parallèle une résistance et le capteur piezo, les broches du capteur piezo : Une broche sur GND l'autre broche sur A0
// Variable pour désigner quelle pin est utilisée pour le capteur
int capteurPiezo = A0; // pin Analog 0
// Variable pour contenir la valeur du capteur
int valeurPiezo ;
int score;
int highscore;

void setup() {
// Établit la connexion série à 9600 bauds
Serial.begin(9600);
pinMode(BUTTON_PIN, INPUT_PULLUP);
highscore = EEPROM.read(600);
//Serial.println("Highscore");Serial.println(highscore);

// set up the LCD's number of columns and rows:
lcd.begin(16, 2);

lcd.setRGB(colorR, colorG, colorB);

// Print a message to the LCD.
lcd.clear();
lcd.setCursor(0,0);

}

void loop() {

currentState = digitalRead(BUTTON_PIN);
//Serial.println("currentState");Serial.println(currentState);

if(currentState==0)
{
delay(100);
if(startgame==0)
{startgame=1;
score=0;
endgame=0;}
else
{startgame=0;
endgame=1;}
}

if (startgame==0)
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Highscore : ");lcd.print(highscore);
if(score!=0)
{
lcd.setCursor(0,1);
lcd.print("Your score : ");lcd.print(score);
}
}

if (startgame==1)
{

// Lit la pin du capteur et l'assigne à la variable valeurPiezo
valeurPiezo = analogRead(capteurPiezo);
// Affiche au moniteur série la valeur de valeurPiezo
if (valeurPiezo >= 1 )
{
score+=1;
//Serial.println("score");Serial.println(score);
}

// Laisse un court délai afin que l'utilisateur puisse lire les valeurs correctement
delay(50);

if(score>highscore)
{EEPROM.write(600,score);
}
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Highscore : ");lcd.print(highscore);
lcd.setCursor(0,1);
lcd.print("Your score : ");lcd.print(score);
}

}

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe C : flipper

2022-01-17T14:51:35Z

Erwann : /* Liste des composants */

==photo de l'équipe==
[[Fichier:Photoenib2018.jpg|600px]]

==Que fait ce projet ? ==
L'objectif est de recréer un flipper taille miniature.

==Liste des composants==

* carte arduino nano
* 2 gachettes de flipper (voir le fichier stl puis les imprimer)
* planches en bois à couper aux bonnes dimensions
* x capteurs piezo avec résistance d'un MegΩ
* 4 élastiques
* une bille
* 1 bouchon en liège
* une tige en bois (dans laquelle on pourra embrocher des bouchons en lièges)

[[media:Haut gachette.stl|vignette|haut des gachettes du flipper]]

==Fichiers à avoir==
* [[Fichier:Haut gachette.stl]] à imprimer en 3D deux fois
* [[Fichier:Bas.stl]] à imprimer en 3D deux fois également

==Sources==
* gestion de la mémoire arduino : https://zestedesavoir.com/tutoriels/374/gestion-de-la-memoire-sur-arduino/

==Code==
<pre>
////////////////////////////////
// Test //
// capteur de pression Piezo //
////////////////////////////////
/*
* vendredi 30 juillet 2021
* D1 mini
* code inspiré de Arduino FlossManual - https://fr.flossmanuals.net/arduino/_draft/_v/1.0/perroquet/
* matériel
* - D1 mini
* - breadboard
* - jumper
* - piezo
* - résistance 10 Mégaohms
*
* * BROCHAGE
_________________
/ D1 mini \
- |[ ]RST TX[ ]| -
Résistance - Capteur Piezo - |[X]A0 -GPIO RX[ ]| -
|[ ]D0-16 5-D1[ ]| -
|[ ]D5-14 4-D2[ ]| -
- |[ ]D6-12 0-D3[ ]| -
- |[ ]D7-13 2-D4[ ]| LED_BUILTIN
- |[ ]D8-15 GND[X]| - GND - Capteur Piezo - resistance
- |[ ]3V3 . 5V[X]| - ruban de Led
| +---+ |
|_______|USB|_______|

* Antony Le Goïc-Auffret
*
*/

// Variable pour désigner quelle pin est utilisée pour le capteur
int capteurPiezo = A0; // pin Analog 0
// Variable pour contenir la valeur du capteur
int valeurPiezo ;

void setup() {
// Établit la connexion série à 9600 bauds
Serial.begin(9600);
}

void loop() {
// Lit la pin du capteur et l'assigne à la variable valeurPiezo
valeurPiezo = analogRead(capteurPiezo);
// Affiche au moniteur série la valeur de valeurPiezo
Serial.println(valeurPiezo);
// Laisse un court délai afin que l'utilisateur puisse lire les valeurs correctement
delay(100);
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe C : flipper

2022-01-17T14:49:41Z

Erwann : /* Fichiers à avoir */

==photo de l'équipe==
[[Fichier:Photoenib2018.jpg|600px]]

==Que fait ce projet ? ==
L'objectif est de recréer un flipper taille miniature.

==Liste des composants==

* carte arduino nano
* 2 gachettes de flipper (voir le fichier stl puis les imprimer)
* planches en bois à couper aux bonnes dimensions
* x capteurs piezo
* 4 élastiques
* une bille
* 1 bouchon en liège
* une tige en bois (dans laquelle on pourra embrocher des bouchons en lièges)

[[media:Haut gachette.stl|vignette|haut des gachettes du flipper]]
==Fichiers à avoir==
* [[Fichier:Haut gachette.stl]] à imprimer en 3D deux fois
* [[Fichier:Bas.stl]] à imprimer en 3D deux fois également

==Sources==
* gestion de la mémoire arduino : https://zestedesavoir.com/tutoriels/374/gestion-de-la-memoire-sur-arduino/

==Code==
<pre>
////////////////////////////////
// Test //
// capteur de pression Piezo //
////////////////////////////////
/*
* vendredi 30 juillet 2021
* D1 mini
* code inspiré de Arduino FlossManual - https://fr.flossmanuals.net/arduino/_draft/_v/1.0/perroquet/
* matériel
* - D1 mini
* - breadboard
* - jumper
* - piezo
* - résistance 10 Mégaohms
*
* * BROCHAGE
_________________
/ D1 mini \
- |[ ]RST TX[ ]| -
Résistance - Capteur Piezo - |[X]A0 -GPIO RX[ ]| -
|[ ]D0-16 5-D1[ ]| -
|[ ]D5-14 4-D2[ ]| -
- |[ ]D6-12 0-D3[ ]| -
- |[ ]D7-13 2-D4[ ]| LED_BUILTIN
- |[ ]D8-15 GND[X]| - GND - Capteur Piezo - resistance
- |[ ]3V3 . 5V[X]| - ruban de Led
| +---+ |
|_______|USB|_______|

* Antony Le Goïc-Auffret
*
*/

// Variable pour désigner quelle pin est utilisée pour le capteur
int capteurPiezo = A0; // pin Analog 0
// Variable pour contenir la valeur du capteur
int valeurPiezo ;

void setup() {
// Établit la connexion série à 9600 bauds
Serial.begin(9600);
}

void loop() {
// Lit la pin du capteur et l'assigne à la variable valeurPiezo
valeurPiezo = analogRead(capteurPiezo);
// Affiche au moniteur série la valeur de valeurPiezo
Serial.println(valeurPiezo);
// Laisse un court délai afin que l'utilisateur puisse lire les valeurs correctement
delay(100);
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe C : flipper

2022-01-17T14:46:43Z

Erwann : /* Fichiers à avoir */

ENIB 2022 - groupe C : flipper

2022-01-17T14:45:13Z

Erwann : /* Fichiers à avoir */

Fichier:Bas.stl

2022-01-17T14:44:55Z

Erwann :

bas des gachettes à emboiter dans la parie supérieur

ENIB 2022 - groupe C : flipper

2022-01-17T14:42:48Z

Erwann : /* Fichiers à avoir */

ENIB 2022 - groupe C : flipper

2022-01-17T14:40:42Z

Erwann : /* Fichiers à avoir */

ENIB 2022 - groupe C : flipper

2022-01-17T14:39:42Z

Erwann : /* Fichiers à avoir */

ENIB 2022 - groupe C : flipper

2022-01-17T14:39:15Z

Erwann : /* Fichiers à avoir */

ENIB 2022 - groupe C : flipper

2022-01-17T14:38:02Z

Erwann : /* Fichiers à avoir */

Fichier:Haut gachette.stl

2022-01-17T14:37:28Z

Erwann :

première partie des gachettes

ENIB 2022 - groupe C : flipper

2022-01-17T14:35:39Z

Erwann :

ENIB 2022 - groupe C : flipper

2022-01-17T14:25:41Z

Erwann : /* Liste des composants */

ENIB 2022 - groupe C : flipper

2022-01-17T14:15:22Z

Erwann : /* Que fait ce projet ? */

ENIB 2022 - groupe C : flipper

2022-01-17T14:12:50Z

Erwann : /* Liste des composants */

==photo de l'équipe==
[[Fichier:Photoenib2018.jpg|600px]]

==Que fait ce projet ? ==

==Liste des composants==

* carte arduino nano
* 2 gachettes de flipper (voir le fichier stl)
* planches en bois à couper aux bonnes dimensions
* x capteurs piezo
* 4 élastiques
* une bille
* 1 bouchon en liège
* une tige en bois (dans laquelle on pourra embrocher des bouchons en lièges)

==Sources==
* gestion de la mémoire arduino : https://zestedesavoir.com/tutoriels/374/gestion-de-la-memoire-sur-arduino/

==Code==
<pre>
////////////////////////////////
// Test //
// capteur de pression Piezo //
////////////////////////////////
/*
* vendredi 30 juillet 2021
* D1 mini
* code inspiré de Arduino FlossManual - https://fr.flossmanuals.net/arduino/_draft/_v/1.0/perroquet/
* matériel
* - D1 mini
* - breadboard
* - jumper
* - piezo
* - résistance 10 Mégaohms
*
* * BROCHAGE
_________________
/ D1 mini \
- |[ ]RST TX[ ]| -
Résistance - Capteur Piezo - |[X]A0 -GPIO RX[ ]| -
|[ ]D0-16 5-D1[ ]| -
|[ ]D5-14 4-D2[ ]| -
- |[ ]D6-12 0-D3[ ]| -
- |[ ]D7-13 2-D4[ ]| LED_BUILTIN
- |[ ]D8-15 GND[X]| - GND - Capteur Piezo - resistance
- |[ ]3V3 . 5V[X]| - ruban de Led
| +---+ |
|_______|USB|_______|

* Antony Le Goïc-Auffret
*
*/

// Variable pour désigner quelle pin est utilisée pour le capteur
int capteurPiezo = A0; // pin Analog 0
// Variable pour contenir la valeur du capteur
int valeurPiezo ;

void setup() {
// Établit la connexion série à 9600 bauds
Serial.begin(9600);
}

void loop() {
// Lit la pin du capteur et l'assigne à la variable valeurPiezo
valeurPiezo = analogRead(capteurPiezo);
// Affiche au moniteur série la valeur de valeurPiezo
Serial.println(valeurPiezo);
// Laisse un court délai afin que l'utilisateur puisse lire les valeurs correctement
delay(100);
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]