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

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-15T11:37:57Z

Miiswitch :

==photo de l'équipe==
<gallery>
Fichier:Roue de la fortune .jpg|vignette
</gallery>

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha BEN OTHMAN

==Que fait ce projet ? ==

Notre projet, la Roue de la Gourmandise, est un projet inspiré de la roue de la fortune.

Il se différencie par la façon dont on tourne la roue.

On utilise ici un bouton poussoir pour allumer une LED dans la bande de LED qui circule au fur et à mesure, et s'arrête à un moment aléatoire.

La roue est divisé en deux côtés, un gagnant et un perdant.

Lorsqu'on gagne, la deuxième partie du projet entre en place, un distributeur de bonbon. Il s'agit d'une boîte avec un récipient à bonbons. Lorsqu'on gagne, un Servo moteur s'active et fait tomber une petite quantité de bonbon dans le bas de la boîte pour que le gagnant puisse les récupérer.
<gallery>
Fichier:300px Arduino roue.jpg|vignette
Fichier:300px Roue gourmandise.jpg|vignette
Fichier:300px Bascule.jpg|vignette
Fichier:Roue de la gourmandise fini.jpg|vignette
Fichier:Distributeur.jpg|vignette
Fichier:Roue seule fini .jpg|vignette
</gallery>

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

==Schéma de cablage==
<gallery>
Fichier:Schema de cablage.jpg|vignette
</gallery>

==Code==
<pre>

// BROCHAGE
// _________________
// / D1 mini \
// |[ ]RST TX[ ]|
// |[ ]A0 -GPIO RX[ ]|
// |[ ]D0-16 5-D1[X]| - data du ruban de led
// |[ ]D5-14 4-D2[ ]|
// |[ ]D6-12 0-D3[ ]|
// |[ ]D7-13 2-D4[ ]| LED_BUILTIN
// |[ ]D8-15 GND[X]| - masse du ruban
// |[ ]3V3 . 5V[X]| - Alim du ruban
// | +---+ |
// |_______|USB|_______|
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

#define broche 5 // broche GPIO du D1 mini sur laquelle est connectÃ© le ruban
#define bouton 2

// Nombre de led du ruban ?
#define nbpixels 38
bool buttonState = HIGH;

// Lors de la configuration de la bibliothÃ¨que NeoPixel,
// nous lui indiquons combien de pixels,
// et quelle broche utiliser pour envoyer des signaux.
Adafruit_NeoPixel pixels(nbpixels, broche, NEO_GRB + NEO_KHZ800);
// pour configurer le ruban :
// nomDuRuban (nombreDePixels, NumeroDeLaBroche, typeDeRuban)
// Les diffÃ©rents types de ruban :
// NEO_KHZ800 800 KHz bitstream (la plupart des produits Neopixel ou rÃ©fÃ©rences de LED w/WS2812)
// NEO_KHZ400 400 KHz (classic 'v1' (pas v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels cablÃ©s pour GRB bitstream (la plupart des produits Neopixel)
// NEO_RGB Pixels cablÃ©s pour RGB bitstream (v1 FLORA pixels, pas les v2)
// NEO_RGBW Pixels cablÃ©s pour RGBW bitstream (produits NeoPixel RGBW)

#define delai 30 // durÃ©e de la pause en millisecondes
Servo myservo;

void setup() {
pinMode(bouton,INPUT_PULLUP);
pixels.begin(); // INITIALISE l'object ruban NeoPixel
pixels.show(); // Ateint tout les pixels aussi vite que possible.
pixels.setBrightness(100); // met la luminositÃ© Ã 1/5 (max = 255)
Serial.begin(9600);
myservo.attach(12);
/////////////////////
//Initialisation du servo moteur
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(1);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(1);
}
//////////////////
}

void loop() {
buttonState=HIGH;
while(buttonState==HIGH){
buttonState=digitalRead(bouton); //Test du bouton
Serial.println("NOK"); //Tant qu'on appuie pas le programme attend
}
Serial.println("OK");
//int nbLap=random(3,10); //Détermination du nombre de tour
int nbLap=2;
//int nbLed=random(0,40); //Détermination de la led qui sera la derniere
int nbLed=5;
buttonState=HIGH;
for(int j=0;j<=nbLap;j++){ // Animation du ruban led où les lumières tournent
for(int i=1; i<=nbpixels; i++){
Serial.print("un");
pixels.setPixelColor(i,pixels.Color(0, 0, 255));
Serial.print("deux");
delay(30);
if(i!=0){
pixels.setPixelColor(i-1,pixels.Color(0, 0, 0));
}
if(j==nbLap && nbLed==i){
if(nbLed>0 && nbLed<=9){ //1ere zone gagnante
win(nbLed);
}
else if(nbLed>=20 && nbLed <=31){ //2eme zone gagnante
win(nbLed);
}
else{ //Zone perdante
lose(nbLed);
}
}
pixels.show(); // met Ã jour le ruban
delay(delai); // Pause
//end:
}
}
}

void win(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(0, 255, 0)); //Led verte clignote 20 fois
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); // Animation de victoire
pixels.show();
delay(200);
//goto end;
}
reward();
return;
}

void lose(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(255, 0, 0)); //Animation de défaite
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); //Led cligote rouge 20fois
pixels.show();
delay(200);
//goto end;
}
}

void reward(){
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(15);
}
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-15T11:37:36Z

Miiswitch :

==photo de l'équipe==
<gallery>
Fichier:Roue de la fortune .jpg|vignette
</gallery>

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha BEN OTHMAN

==Que fait ce projet ? ==

Notre projet, la Roue de la Gourmandise, est un projet inspiré de la roue de la fortune.

Il se différencie par la façon dont on tourne la roue.

On utilise ici un bouton poussoir pour allumer une LED dans la bande de LED qui circule au fur et à mesure, et s'arrête à un moment aléatoire.

La roue est divisé en deux côtés, un gagnant et un perdant.

Lorsqu'on gagne, la deuxième partie du projet entre en place, un distributeur de bonbon. Il s'agit d'une boîte avec un récipient à bonbons. Lorsqu'on gagne, un Servo moteur s'active et fait tomber une petite quantité de bonbon dans le bas de la boîte pour que le gagnant puisse les récupérer.
<gallery>
Fichier:300px Arduino roue.jpg|vignette
Fichier:300px Roue gourmandise.jpg|vignette
Fichier:300px Bascule.jpg|vignette
[[Fichier:Roue de la gourmandise fini.jpg|vignette]]
[[Fichier:Distributeur.jpg|vignette]]
[[Fichier:Roue seule fini .jpg|vignette]]
</gallery>

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

==Schéma de cablage==
<gallery>
Fichier:Schema de cablage.jpg|vignette
</gallery>

==Code==
<pre>

// BROCHAGE
// _________________
// / D1 mini \
// |[ ]RST TX[ ]|
// |[ ]A0 -GPIO RX[ ]|
// |[ ]D0-16 5-D1[X]| - data du ruban de led
// |[ ]D5-14 4-D2[ ]|
// |[ ]D6-12 0-D3[ ]|
// |[ ]D7-13 2-D4[ ]| LED_BUILTIN
// |[ ]D8-15 GND[X]| - masse du ruban
// |[ ]3V3 . 5V[X]| - Alim du ruban
// | +---+ |
// |_______|USB|_______|
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

#define broche 5 // broche GPIO du D1 mini sur laquelle est connectÃ© le ruban
#define bouton 2

// Nombre de led du ruban ?
#define nbpixels 38
bool buttonState = HIGH;

// Lors de la configuration de la bibliothÃ¨que NeoPixel,
// nous lui indiquons combien de pixels,
// et quelle broche utiliser pour envoyer des signaux.
Adafruit_NeoPixel pixels(nbpixels, broche, NEO_GRB + NEO_KHZ800);
// pour configurer le ruban :
// nomDuRuban (nombreDePixels, NumeroDeLaBroche, typeDeRuban)
// Les diffÃ©rents types de ruban :
// NEO_KHZ800 800 KHz bitstream (la plupart des produits Neopixel ou rÃ©fÃ©rences de LED w/WS2812)
// NEO_KHZ400 400 KHz (classic 'v1' (pas v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels cablÃ©s pour GRB bitstream (la plupart des produits Neopixel)
// NEO_RGB Pixels cablÃ©s pour RGB bitstream (v1 FLORA pixels, pas les v2)
// NEO_RGBW Pixels cablÃ©s pour RGBW bitstream (produits NeoPixel RGBW)

#define delai 30 // durÃ©e de la pause en millisecondes
Servo myservo;

void setup() {
pinMode(bouton,INPUT_PULLUP);
pixels.begin(); // INITIALISE l'object ruban NeoPixel
pixels.show(); // Ateint tout les pixels aussi vite que possible.
pixels.setBrightness(100); // met la luminositÃ© Ã 1/5 (max = 255)
Serial.begin(9600);
myservo.attach(12);
/////////////////////
//Initialisation du servo moteur
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(1);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(1);
}
//////////////////
}

void loop() {
buttonState=HIGH;
while(buttonState==HIGH){
buttonState=digitalRead(bouton); //Test du bouton
Serial.println("NOK"); //Tant qu'on appuie pas le programme attend
}
Serial.println("OK");
//int nbLap=random(3,10); //Détermination du nombre de tour
int nbLap=2;
//int nbLed=random(0,40); //Détermination de la led qui sera la derniere
int nbLed=5;
buttonState=HIGH;
for(int j=0;j<=nbLap;j++){ // Animation du ruban led où les lumières tournent
for(int i=1; i<=nbpixels; i++){
Serial.print("un");
pixels.setPixelColor(i,pixels.Color(0, 0, 255));
Serial.print("deux");
delay(30);
if(i!=0){
pixels.setPixelColor(i-1,pixels.Color(0, 0, 0));
}
if(j==nbLap && nbLed==i){
if(nbLed>0 && nbLed<=9){ //1ere zone gagnante
win(nbLed);
}
else if(nbLed>=20 && nbLed <=31){ //2eme zone gagnante
win(nbLed);
}
else{ //Zone perdante
lose(nbLed);
}
}
pixels.show(); // met Ã jour le ruban
delay(delai); // Pause
//end:
}
}
}

void win(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(0, 255, 0)); //Led verte clignote 20 fois
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); // Animation de victoire
pixels.show();
delay(200);
//goto end;
}
reward();
return;
}

void lose(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(255, 0, 0)); //Animation de défaite
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); //Led cligote rouge 20fois
pixels.show();
delay(200);
//goto end;
}
}

void reward(){
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(15);
}
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

Fichier:Roue seule fini .jpg

2022-01-15T11:37:33Z

Miiswitch :

roue seule fini

Fichier:Distributeur.jpg

2022-01-15T11:37:09Z

Miiswitch :

distributeur

Fichier:Roue de la gourmandise fini.jpg

2022-01-15T11:36:45Z

Miiswitch :

Roue de la gourmandise fini

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-15T11:35:49Z

Miiswitch :

==photo de l'équipe==
<gallery>
Fichier:Roue de la fortune .jpg|vignette
</gallery>

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha BEN OTHMAN

==Que fait ce projet ? ==

Notre projet, la Roue de la Gourmandise, est un projet inspiré de la roue de la fortune.

Il se différencie par la façon dont on tourne la roue.

On utilise ici un bouton poussoir pour allumer une LED dans la bande de LED qui circule au fur et à mesure, et s'arrête à un moment aléatoire.

La roue est divisé en deux côtés, un gagnant et un perdant.

Lorsqu'on gagne, la deuxième partie du projet entre en place, un distributeur de bonbon. Il s'agit d'une boîte avec un récipient à bonbons. Lorsqu'on gagne, un Servo moteur s'active et fait tomber une petite quantité de bonbon dans le bas de la boîte pour que le gagnant puisse les récupérer.
<gallery>
Fichier:300px Arduino roue.jpg|vignette
Fichier:300px Roue gourmandise.jpg|vignette
Fichier:300px Bascule.jpg|vignette
</gallery>

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

==Schéma de cablage==
<gallery>
Fichier:Schema de cablage.jpg|vignette
</gallery>

==Code==
<pre>

// BROCHAGE
// _________________
// / D1 mini \
// |[ ]RST TX[ ]|
// |[ ]A0 -GPIO RX[ ]|
// |[ ]D0-16 5-D1[X]| - data du ruban de led
// |[ ]D5-14 4-D2[ ]|
// |[ ]D6-12 0-D3[ ]|
// |[ ]D7-13 2-D4[ ]| LED_BUILTIN
// |[ ]D8-15 GND[X]| - masse du ruban
// |[ ]3V3 . 5V[X]| - Alim du ruban
// | +---+ |
// |_______|USB|_______|
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

#define broche 5 // broche GPIO du D1 mini sur laquelle est connectÃ© le ruban
#define bouton 2

// Nombre de led du ruban ?
#define nbpixels 38
bool buttonState = HIGH;

// Lors de la configuration de la bibliothÃ¨que NeoPixel,
// nous lui indiquons combien de pixels,
// et quelle broche utiliser pour envoyer des signaux.
Adafruit_NeoPixel pixels(nbpixels, broche, NEO_GRB + NEO_KHZ800);
// pour configurer le ruban :
// nomDuRuban (nombreDePixels, NumeroDeLaBroche, typeDeRuban)
// Les diffÃ©rents types de ruban :
// NEO_KHZ800 800 KHz bitstream (la plupart des produits Neopixel ou rÃ©fÃ©rences de LED w/WS2812)
// NEO_KHZ400 400 KHz (classic 'v1' (pas v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels cablÃ©s pour GRB bitstream (la plupart des produits Neopixel)
// NEO_RGB Pixels cablÃ©s pour RGB bitstream (v1 FLORA pixels, pas les v2)
// NEO_RGBW Pixels cablÃ©s pour RGBW bitstream (produits NeoPixel RGBW)

#define delai 30 // durÃ©e de la pause en millisecondes
Servo myservo;

void setup() {
pinMode(bouton,INPUT_PULLUP);
pixels.begin(); // INITIALISE l'object ruban NeoPixel
pixels.show(); // Ateint tout les pixels aussi vite que possible.
pixels.setBrightness(100); // met la luminositÃ© Ã 1/5 (max = 255)
Serial.begin(9600);
myservo.attach(12);
/////////////////////
//Initialisation du servo moteur
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(1);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(1);
}
//////////////////
}

void loop() {
buttonState=HIGH;
while(buttonState==HIGH){
buttonState=digitalRead(bouton); //Test du bouton
Serial.println("NOK"); //Tant qu'on appuie pas le programme attend
}
Serial.println("OK");
//int nbLap=random(3,10); //Détermination du nombre de tour
int nbLap=2;
//int nbLed=random(0,40); //Détermination de la led qui sera la derniere
int nbLed=5;
buttonState=HIGH;
for(int j=0;j<=nbLap;j++){ // Animation du ruban led où les lumières tournent
for(int i=1; i<=nbpixels; i++){
Serial.print("un");
pixels.setPixelColor(i,pixels.Color(0, 0, 255));
Serial.print("deux");
delay(30);
if(i!=0){
pixels.setPixelColor(i-1,pixels.Color(0, 0, 0));
}
if(j==nbLap && nbLed==i){
if(nbLed>0 && nbLed<=9){ //1ere zone gagnante
win(nbLed);
}
else if(nbLed>=20 && nbLed <=31){ //2eme zone gagnante
win(nbLed);
}
else{ //Zone perdante
lose(nbLed);
}
}
pixels.show(); // met Ã jour le ruban
delay(delai); // Pause
//end:
}
}
}

void win(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(0, 255, 0)); //Led verte clignote 20 fois
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); // Animation de victoire
pixels.show();
delay(200);
//goto end;
}
reward();
return;
}

void lose(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(255, 0, 0)); //Animation de défaite
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); //Led cligote rouge 20fois
pixels.show();
delay(200);
//goto end;
}
}

void reward(){
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(15);
}
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-15T11:35:25Z

Miiswitch :

==photo de l'équipe==
[[Fichier:Roue de la fortune .jpg|vignette]]

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha BEN OTHMAN

==Que fait ce projet ? ==

Notre projet, la Roue de la Gourmandise, est un projet inspiré de la roue de la fortune.

Il se différencie par la façon dont on tourne la roue.

On utilise ici un bouton poussoir pour allumer une LED dans la bande de LED qui circule au fur et à mesure, et s'arrête à un moment aléatoire.

La roue est divisé en deux côtés, un gagnant et un perdant.

Lorsqu'on gagne, la deuxième partie du projet entre en place, un distributeur de bonbon. Il s'agit d'une boîte avec un récipient à bonbons. Lorsqu'on gagne, un Servo moteur s'active et fait tomber une petite quantité de bonbon dans le bas de la boîte pour que le gagnant puisse les récupérer.
<gallery>
Fichier:300px Arduino roue.jpg|vignette
Fichier:300px Roue gourmandise.jpg|vignette
Fichier:300px Bascule.jpg|vignette
</gallery>

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

==Schéma de cablage==
<gallery>
Fichier:Schema de cablage.jpg|vignette
</gallery>

==Code==
<pre>

// BROCHAGE
// _________________
// / D1 mini \
// |[ ]RST TX[ ]|
// |[ ]A0 -GPIO RX[ ]|
// |[ ]D0-16 5-D1[X]| - data du ruban de led
// |[ ]D5-14 4-D2[ ]|
// |[ ]D6-12 0-D3[ ]|
// |[ ]D7-13 2-D4[ ]| LED_BUILTIN
// |[ ]D8-15 GND[X]| - masse du ruban
// |[ ]3V3 . 5V[X]| - Alim du ruban
// | +---+ |
// |_______|USB|_______|
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

#define broche 5 // broche GPIO du D1 mini sur laquelle est connectÃ© le ruban
#define bouton 2

// Nombre de led du ruban ?
#define nbpixels 38
bool buttonState = HIGH;

// Lors de la configuration de la bibliothÃ¨que NeoPixel,
// nous lui indiquons combien de pixels,
// et quelle broche utiliser pour envoyer des signaux.
Adafruit_NeoPixel pixels(nbpixels, broche, NEO_GRB + NEO_KHZ800);
// pour configurer le ruban :
// nomDuRuban (nombreDePixels, NumeroDeLaBroche, typeDeRuban)
// Les diffÃ©rents types de ruban :
// NEO_KHZ800 800 KHz bitstream (la plupart des produits Neopixel ou rÃ©fÃ©rences de LED w/WS2812)
// NEO_KHZ400 400 KHz (classic 'v1' (pas v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels cablÃ©s pour GRB bitstream (la plupart des produits Neopixel)
// NEO_RGB Pixels cablÃ©s pour RGB bitstream (v1 FLORA pixels, pas les v2)
// NEO_RGBW Pixels cablÃ©s pour RGBW bitstream (produits NeoPixel RGBW)

#define delai 30 // durÃ©e de la pause en millisecondes
Servo myservo;

void setup() {
pinMode(bouton,INPUT_PULLUP);
pixels.begin(); // INITIALISE l'object ruban NeoPixel
pixels.show(); // Ateint tout les pixels aussi vite que possible.
pixels.setBrightness(100); // met la luminositÃ© Ã 1/5 (max = 255)
Serial.begin(9600);
myservo.attach(12);
/////////////////////
//Initialisation du servo moteur
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(1);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(1);
}
//////////////////
}

void loop() {
buttonState=HIGH;
while(buttonState==HIGH){
buttonState=digitalRead(bouton); //Test du bouton
Serial.println("NOK"); //Tant qu'on appuie pas le programme attend
}
Serial.println("OK");
//int nbLap=random(3,10); //Détermination du nombre de tour
int nbLap=2;
//int nbLed=random(0,40); //Détermination de la led qui sera la derniere
int nbLed=5;
buttonState=HIGH;
for(int j=0;j<=nbLap;j++){ // Animation du ruban led où les lumières tournent
for(int i=1; i<=nbpixels; i++){
Serial.print("un");
pixels.setPixelColor(i,pixels.Color(0, 0, 255));
Serial.print("deux");
delay(30);
if(i!=0){
pixels.setPixelColor(i-1,pixels.Color(0, 0, 0));
}
if(j==nbLap && nbLed==i){
if(nbLed>0 && nbLed<=9){ //1ere zone gagnante
win(nbLed);
}
else if(nbLed>=20 && nbLed <=31){ //2eme zone gagnante
win(nbLed);
}
else{ //Zone perdante
lose(nbLed);
}
}
pixels.show(); // met Ã jour le ruban
delay(delai); // Pause
//end:
}
}
}

void win(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(0, 255, 0)); //Led verte clignote 20 fois
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); // Animation de victoire
pixels.show();
delay(200);
//goto end;
}
reward();
return;
}

void lose(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(255, 0, 0)); //Animation de défaite
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); //Led cligote rouge 20fois
pixels.show();
delay(200);
//goto end;
}
}

void reward(){
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(15);
}
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-15T11:35:13Z

Miiswitch :

==photo de l'équipe==
[Fichier:Roue de la fortune .jpg|vignette]

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha BEN OTHMAN

==Que fait ce projet ? ==

Notre projet, la Roue de la Gourmandise, est un projet inspiré de la roue de la fortune.

Il se différencie par la façon dont on tourne la roue.

On utilise ici un bouton poussoir pour allumer une LED dans la bande de LED qui circule au fur et à mesure, et s'arrête à un moment aléatoire.

La roue est divisé en deux côtés, un gagnant et un perdant.

Lorsqu'on gagne, la deuxième partie du projet entre en place, un distributeur de bonbon. Il s'agit d'une boîte avec un récipient à bonbons. Lorsqu'on gagne, un Servo moteur s'active et fait tomber une petite quantité de bonbon dans le bas de la boîte pour que le gagnant puisse les récupérer.
<gallery>
Fichier:300px Arduino roue.jpg|vignette
Fichier:300px Roue gourmandise.jpg|vignette
Fichier:300px Bascule.jpg|vignette
</gallery>

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

==Schéma de cablage==
<gallery>
Fichier:Schema de cablage.jpg|vignette
</gallery>

==Code==
<pre>

// BROCHAGE
// _________________
// / D1 mini \
// |[ ]RST TX[ ]|
// |[ ]A0 -GPIO RX[ ]|
// |[ ]D0-16 5-D1[X]| - data du ruban de led
// |[ ]D5-14 4-D2[ ]|
// |[ ]D6-12 0-D3[ ]|
// |[ ]D7-13 2-D4[ ]| LED_BUILTIN
// |[ ]D8-15 GND[X]| - masse du ruban
// |[ ]3V3 . 5V[X]| - Alim du ruban
// | +---+ |
// |_______|USB|_______|
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

#define broche 5 // broche GPIO du D1 mini sur laquelle est connectÃ© le ruban
#define bouton 2

// Nombre de led du ruban ?
#define nbpixels 38
bool buttonState = HIGH;

// Lors de la configuration de la bibliothÃ¨que NeoPixel,
// nous lui indiquons combien de pixels,
// et quelle broche utiliser pour envoyer des signaux.
Adafruit_NeoPixel pixels(nbpixels, broche, NEO_GRB + NEO_KHZ800);
// pour configurer le ruban :
// nomDuRuban (nombreDePixels, NumeroDeLaBroche, typeDeRuban)
// Les diffÃ©rents types de ruban :
// NEO_KHZ800 800 KHz bitstream (la plupart des produits Neopixel ou rÃ©fÃ©rences de LED w/WS2812)
// NEO_KHZ400 400 KHz (classic 'v1' (pas v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels cablÃ©s pour GRB bitstream (la plupart des produits Neopixel)
// NEO_RGB Pixels cablÃ©s pour RGB bitstream (v1 FLORA pixels, pas les v2)
// NEO_RGBW Pixels cablÃ©s pour RGBW bitstream (produits NeoPixel RGBW)

#define delai 30 // durÃ©e de la pause en millisecondes
Servo myservo;

void setup() {
pinMode(bouton,INPUT_PULLUP);
pixels.begin(); // INITIALISE l'object ruban NeoPixel
pixels.show(); // Ateint tout les pixels aussi vite que possible.
pixels.setBrightness(100); // met la luminositÃ© Ã 1/5 (max = 255)
Serial.begin(9600);
myservo.attach(12);
/////////////////////
//Initialisation du servo moteur
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(1);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(1);
}
//////////////////
}

void loop() {
buttonState=HIGH;
while(buttonState==HIGH){
buttonState=digitalRead(bouton); //Test du bouton
Serial.println("NOK"); //Tant qu'on appuie pas le programme attend
}
Serial.println("OK");
//int nbLap=random(3,10); //Détermination du nombre de tour
int nbLap=2;
//int nbLed=random(0,40); //Détermination de la led qui sera la derniere
int nbLed=5;
buttonState=HIGH;
for(int j=0;j<=nbLap;j++){ // Animation du ruban led où les lumières tournent
for(int i=1; i<=nbpixels; i++){
Serial.print("un");
pixels.setPixelColor(i,pixels.Color(0, 0, 255));
Serial.print("deux");
delay(30);
if(i!=0){
pixels.setPixelColor(i-1,pixels.Color(0, 0, 0));
}
if(j==nbLap && nbLed==i){
if(nbLed>0 && nbLed<=9){ //1ere zone gagnante
win(nbLed);
}
else if(nbLed>=20 && nbLed <=31){ //2eme zone gagnante
win(nbLed);
}
else{ //Zone perdante
lose(nbLed);
}
}
pixels.show(); // met Ã jour le ruban
delay(delai); // Pause
//end:
}
}
}

void win(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(0, 255, 0)); //Led verte clignote 20 fois
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); // Animation de victoire
pixels.show();
delay(200);
//goto end;
}
reward();
return;
}

void lose(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(255, 0, 0)); //Animation de défaite
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); //Led cligote rouge 20fois
pixels.show();
delay(200);
//goto end;
}
}

void reward(){
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(15);
}
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-15T11:35:01Z

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

Fichier:Roue de la fortune .jpg

2022-01-15T11:34:53Z

Miiswitch :

roue de la fortune

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-14T15:26:53Z

Miiswitch :

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

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha BEN OTHMAN

==Que fait ce projet ? ==

Notre projet, la Roue de la Gourmandise, est un projet inspiré de la roue de la fortune.

Il se différencie par la façon dont on tourne la roue.

On utilise ici un bouton poussoir pour allumer une LED dans la bande de LED qui circule au fur et à mesure, et s'arrête à un moment aléatoire.

La roue est divisé en deux côtés, un gagnant et un perdant.

Lorsqu'on gagne, la deuxième partie du projet entre en place, un distributeur de bonbon. Il s'agit d'une boîte avec un récipient à bonbons. Lorsqu'on gagne, un Servo moteur s'active et fait tomber une petite quantité de bonbon dans le bas de la boîte pour que le gagnant puisse les récupérer.
<gallery>
Fichier:300px Arduino roue.jpg|vignette
Fichier:300px Roue gourmandise.jpg|vignette
Fichier:300px Bascule.jpg|vignette
</gallery>

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

==Schéma de cablage==
<gallery>
Fichier:Schema de cablage.jpg|vignette
</gallery>

==Code==
<pre>

// BROCHAGE
// _________________
// / D1 mini \
// |[ ]RST TX[ ]|
// |[ ]A0 -GPIO RX[ ]|
// |[ ]D0-16 5-D1[X]| - data du ruban de led
// |[ ]D5-14 4-D2[ ]|
// |[ ]D6-12 0-D3[ ]|
// |[ ]D7-13 2-D4[ ]| LED_BUILTIN
// |[ ]D8-15 GND[X]| - masse du ruban
// |[ ]3V3 . 5V[X]| - Alim du ruban
// | +---+ |
// |_______|USB|_______|
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

#define broche 5 // broche GPIO du D1 mini sur laquelle est connectÃ© le ruban
#define bouton 2

// Nombre de led du ruban ?
#define nbpixels 38
bool buttonState = HIGH;

// Lors de la configuration de la bibliothÃ¨que NeoPixel,
// nous lui indiquons combien de pixels,
// et quelle broche utiliser pour envoyer des signaux.
Adafruit_NeoPixel pixels(nbpixels, broche, NEO_GRB + NEO_KHZ800);
// pour configurer le ruban :
// nomDuRuban (nombreDePixels, NumeroDeLaBroche, typeDeRuban)
// Les diffÃ©rents types de ruban :
// NEO_KHZ800 800 KHz bitstream (la plupart des produits Neopixel ou rÃ©fÃ©rences de LED w/WS2812)
// NEO_KHZ400 400 KHz (classic 'v1' (pas v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels cablÃ©s pour GRB bitstream (la plupart des produits Neopixel)
// NEO_RGB Pixels cablÃ©s pour RGB bitstream (v1 FLORA pixels, pas les v2)
// NEO_RGBW Pixels cablÃ©s pour RGBW bitstream (produits NeoPixel RGBW)

#define delai 30 // durÃ©e de la pause en millisecondes
Servo myservo;

void setup() {
pinMode(bouton,INPUT_PULLUP);
pixels.begin(); // INITIALISE l'object ruban NeoPixel
pixels.show(); // Ateint tout les pixels aussi vite que possible.
pixels.setBrightness(100); // met la luminositÃ© Ã 1/5 (max = 255)
Serial.begin(9600);
myservo.attach(12);
/////////////////////
//Initialisation du servo moteur
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(1);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(1);
}
//////////////////
}

void loop() {
buttonState=HIGH;
while(buttonState==HIGH){
buttonState=digitalRead(bouton); //Test du bouton
Serial.println("NOK"); //Tant qu'on appuie pas le programme attend
}
Serial.println("OK");
//int nbLap=random(3,10); //Détermination du nombre de tour
int nbLap=2;
//int nbLed=random(0,40); //Détermination de la led qui sera la derniere
int nbLed=5;
buttonState=HIGH;
for(int j=0;j<=nbLap;j++){ // Animation du ruban led où les lumières tournent
for(int i=1; i<=nbpixels; i++){
Serial.print("un");
pixels.setPixelColor(i,pixels.Color(0, 0, 255));
Serial.print("deux");
delay(30);
if(i!=0){
pixels.setPixelColor(i-1,pixels.Color(0, 0, 0));
}
if(j==nbLap && nbLed==i){
if(nbLed>0 && nbLed<=9){ //1ere zone gagnante
win(nbLed);
}
else if(nbLed>=20 && nbLed <=31){ //2eme zone gagnante
win(nbLed);
}
else{ //Zone perdante
lose(nbLed);
}
}
pixels.show(); // met Ã jour le ruban
delay(delai); // Pause
//end:
}
}
}

void win(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(0, 255, 0)); //Led verte clignote 20 fois
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); // Animation de victoire
pixels.show();
delay(200);
//goto end;
}
reward();
return;
}

void lose(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(255, 0, 0)); //Animation de défaite
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); //Led cligote rouge 20fois
pixels.show();
delay(200);
//goto end;
}
}

void reward(){
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(15);
}
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-14T15:26:21Z

Miiswitch : /* Que fait ce projet ? */

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

[[Fichier:Roue gourmandise.jpg|vignette]]
[[Fichier:Bascule.jpg|vignette]]
[[Fichier:Arduino roue.jpg|vignette]]

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha ben othman

==Que fait ce projet ? ==

Notre projet, la Roue de la Gourmandise, est un projet inspiré de la roue de la fortune.

Il se différencie par la façon dont on tourne la roue.

On utilise ici un bouton poussoir pour allumer une LED dans la bande de LED qui circule au fur et à mesure, et s'arrête à un moment aléatoire.

La roue est divisé en deux côtés, un gagnant et un perdant.

Lorsqu'on gagne, la deuxième partie du projet entre en place, un distributeur de bonbon. Il s'agit d'une boîte avec un récipient à bonbons. Lorsqu'on gagne, un Servo moteur s'active et fait tomber une petite quantité de bonbon dans le bas de la boîte pour que le gagnant puisse les récupérer.
<gallery>
Fichier:300px Arduino roue.jpg|vignette
Fichier:300px Roue gourmandise.jpg|vignette
Fichier:300px Bascule.jpg|vignette
</gallery>

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

==Schéma de cablage==
<gallery>
Fichier:Schema de cablage.jpg|vignette
</gallery>

==Code==
<pre>

// BROCHAGE
// _________________
// / D1 mini \
// |[ ]RST TX[ ]|
// |[ ]A0 -GPIO RX[ ]|
// |[ ]D0-16 5-D1[X]| - data du ruban de led
// |[ ]D5-14 4-D2[ ]|
// |[ ]D6-12 0-D3[ ]|
// |[ ]D7-13 2-D4[ ]| LED_BUILTIN
// |[ ]D8-15 GND[X]| - masse du ruban
// |[ ]3V3 . 5V[X]| - Alim du ruban
// | +---+ |
// |_______|USB|_______|
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

#define broche 5 // broche GPIO du D1 mini sur laquelle est connectÃ© le ruban
#define bouton 2

// Nombre de led du ruban ?
#define nbpixels 38
bool buttonState = HIGH;

// Lors de la configuration de la bibliothÃ¨que NeoPixel,
// nous lui indiquons combien de pixels,
// et quelle broche utiliser pour envoyer des signaux.
Adafruit_NeoPixel pixels(nbpixels, broche, NEO_GRB + NEO_KHZ800);
// pour configurer le ruban :
// nomDuRuban (nombreDePixels, NumeroDeLaBroche, typeDeRuban)
// Les diffÃ©rents types de ruban :
// NEO_KHZ800 800 KHz bitstream (la plupart des produits Neopixel ou rÃ©fÃ©rences de LED w/WS2812)
// NEO_KHZ400 400 KHz (classic 'v1' (pas v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels cablÃ©s pour GRB bitstream (la plupart des produits Neopixel)
// NEO_RGB Pixels cablÃ©s pour RGB bitstream (v1 FLORA pixels, pas les v2)
// NEO_RGBW Pixels cablÃ©s pour RGBW bitstream (produits NeoPixel RGBW)

#define delai 30 // durÃ©e de la pause en millisecondes
Servo myservo;

void setup() {
pinMode(bouton,INPUT_PULLUP);
pixels.begin(); // INITIALISE l'object ruban NeoPixel
pixels.show(); // Ateint tout les pixels aussi vite que possible.
pixels.setBrightness(100); // met la luminositÃ© Ã 1/5 (max = 255)
Serial.begin(9600);
myservo.attach(12);
/////////////////////
//Initialisation du servo moteur
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(1);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(1);
}
//////////////////
}

void loop() {
buttonState=HIGH;
while(buttonState==HIGH){
buttonState=digitalRead(bouton); //Test du bouton
Serial.println("NOK"); //Tant qu'on appuie pas le programme attend
}
Serial.println("OK");
//int nbLap=random(3,10); //Détermination du nombre de tour
int nbLap=2;
//int nbLed=random(0,40); //Détermination de la led qui sera la derniere
int nbLed=5;
buttonState=HIGH;
for(int j=0;j<=nbLap;j++){ // Animation du ruban led où les lumières tournent
for(int i=1; i<=nbpixels; i++){
Serial.print("un");
pixels.setPixelColor(i,pixels.Color(0, 0, 255));
Serial.print("deux");
delay(30);
if(i!=0){
pixels.setPixelColor(i-1,pixels.Color(0, 0, 0));
}
if(j==nbLap && nbLed==i){
if(nbLed>0 && nbLed<=9){ //1ere zone gagnante
win(nbLed);
}
else if(nbLed>=20 && nbLed <=31){ //2eme zone gagnante
win(nbLed);
}
else{ //Zone perdante
lose(nbLed);
}
}
pixels.show(); // met Ã jour le ruban
delay(delai); // Pause
//end:
}
}
}

void win(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(0, 255, 0)); //Led verte clignote 20 fois
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); // Animation de victoire
pixels.show();
delay(200);
//goto end;
}
reward();
return;
}

void lose(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(255, 0, 0)); //Animation de défaite
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); //Led cligote rouge 20fois
pixels.show();
delay(200);
//goto end;
}
}

void reward(){
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(15);
}
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

Fichier:300px Bascule.jpg

2022-01-14T15:26:00Z

Miiswitch :

ccc

Fichier:300px Roue gourmandise.jpg

2022-01-14T15:25:27Z

Miiswitch :

jhkj,l;

Fichier:300px Arduino roue.jpg

2022-01-14T15:24:35Z

Miiswitch :

nbjnk,l

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-14T15:21:55Z

Miiswitch :

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

[[Fichier:Roue gourmandise.jpg|vignette]]
[[Fichier:Bascule.jpg|vignette]]
[[Fichier:Arduino roue.jpg|vignette]]

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha ben othman

==Que fait ce projet ? ==

Notre projet, la Roue de la Gourmandise, est un projet inspiré de la roue de la fortune.

Il se différencie par la façon dont on tourne la roue.

On utilise ici un bouton poussoir pour allumer une LED dans la bande de LED qui circule au fur et à mesure, et s'arrête à un moment aléatoire.

La roue est divisé en deux côtés, un gagnant et un perdant.

Lorsqu'on gagne, la deuxième partie du projet entre en place, un distributeur de bonbon. Il s'agit d'une boîte avec un récipient à bonbons. Lorsqu'on gagne, un Servo moteur s'active et fait tomber une petite quantité de bonbon dans le bas de la boîte pour que le gagnant puisse les récupérer.

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

==Schéma de cablage==
<gallery>
Fichier:Schema de cablage.jpg|vignette
</gallery>

==Code==
<pre>

// BROCHAGE
// _________________
// / D1 mini \
// |[ ]RST TX[ ]|
// |[ ]A0 -GPIO RX[ ]|
// |[ ]D0-16 5-D1[X]| - data du ruban de led
// |[ ]D5-14 4-D2[ ]|
// |[ ]D6-12 0-D3[ ]|
// |[ ]D7-13 2-D4[ ]| LED_BUILTIN
// |[ ]D8-15 GND[X]| - masse du ruban
// |[ ]3V3 . 5V[X]| - Alim du ruban
// | +---+ |
// |_______|USB|_______|
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

#define broche 5 // broche GPIO du D1 mini sur laquelle est connectÃ© le ruban
#define bouton 2

// Nombre de led du ruban ?
#define nbpixels 38
bool buttonState = HIGH;

// Lors de la configuration de la bibliothÃ¨que NeoPixel,
// nous lui indiquons combien de pixels,
// et quelle broche utiliser pour envoyer des signaux.
Adafruit_NeoPixel pixels(nbpixels, broche, NEO_GRB + NEO_KHZ800);
// pour configurer le ruban :
// nomDuRuban (nombreDePixels, NumeroDeLaBroche, typeDeRuban)
// Les diffÃ©rents types de ruban :
// NEO_KHZ800 800 KHz bitstream (la plupart des produits Neopixel ou rÃ©fÃ©rences de LED w/WS2812)
// NEO_KHZ400 400 KHz (classic 'v1' (pas v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels cablÃ©s pour GRB bitstream (la plupart des produits Neopixel)
// NEO_RGB Pixels cablÃ©s pour RGB bitstream (v1 FLORA pixels, pas les v2)
// NEO_RGBW Pixels cablÃ©s pour RGBW bitstream (produits NeoPixel RGBW)

#define delai 30 // durÃ©e de la pause en millisecondes
Servo myservo;

void setup() {
pinMode(bouton,INPUT_PULLUP);
pixels.begin(); // INITIALISE l'object ruban NeoPixel
pixels.show(); // Ateint tout les pixels aussi vite que possible.
pixels.setBrightness(100); // met la luminositÃ© Ã 1/5 (max = 255)
Serial.begin(9600);
myservo.attach(12);
/////////////////////
//Initialisation du servo moteur
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(1);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(1);
}
//////////////////
}

void loop() {
buttonState=HIGH;
while(buttonState==HIGH){
buttonState=digitalRead(bouton); //Test du bouton
Serial.println("NOK"); //Tant qu'on appuie pas le programme attend
}
Serial.println("OK");
//int nbLap=random(3,10); //Détermination du nombre de tour
int nbLap=2;
//int nbLed=random(0,40); //Détermination de la led qui sera la derniere
int nbLed=5;
buttonState=HIGH;
for(int j=0;j<=nbLap;j++){ // Animation du ruban led où les lumières tournent
for(int i=1; i<=nbpixels; i++){
Serial.print("un");
pixels.setPixelColor(i,pixels.Color(0, 0, 255));
Serial.print("deux");
delay(30);
if(i!=0){
pixels.setPixelColor(i-1,pixels.Color(0, 0, 0));
}
if(j==nbLap && nbLed==i){
if(nbLed>0 && nbLed<=9){ //1ere zone gagnante
win(nbLed);
}
else if(nbLed>=20 && nbLed <=31){ //2eme zone gagnante
win(nbLed);
}
else{ //Zone perdante
lose(nbLed);
}
}
pixels.show(); // met Ã jour le ruban
delay(delai); // Pause
//end:
}
}
}

void win(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(0, 255, 0)); //Led verte clignote 20 fois
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); // Animation de victoire
pixels.show();
delay(200);
//goto end;
}
reward();
return;
}

void lose(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(255, 0, 0)); //Animation de défaite
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); //Led cligote rouge 20fois
pixels.show();
delay(200);
//goto end;
}
}

void reward(){
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(15);
}
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-14T15:21:07Z

Miiswitch : /* Schéma de cablage */

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

[[Fichier:Roue gourmandise.jpg|vignette]]
[[Fichier:Bascule.jpg|vignette]]
[[Fichier:Arduino roue.jpg|vignette]]

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha ben othman

==Que fait ce projet ? ==

Notre projet, la Roue de la Gourmandise, est un projet inspiré de la roue de la fortune.

Il se différencie par la façon dont on tourne la roue.

On utilise ici un bouton poussoir pour allumer une LED dans la bande de LED qui circule au fur et à mesure, et s'arrête à un moment aléatoire.

La roue est divisé en deux côtés, un gagnant et un perdant.

Lorsqu'on gagne, la deuxième partie du projet entre en place, un distributeur de bonbon. Il s'agit d'une boîte avec un récipient à bonbons. Lorsqu'on gagne, un Servo moteur s'active et fait tomber une petite quantité de bonbon dans le bas de la boîte pour que le gagnant puisse les récupérer.

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

[[Fichier:Schema de cablage.jpg|vignette]]
==Schéma de cablage==
<gallery>
Fichier:Schema de cablage.jpg|vignette
</gallery>

==Code==
<pre>

// BROCHAGE
// _________________
// / D1 mini \
// |[ ]RST TX[ ]|
// |[ ]A0 -GPIO RX[ ]|
// |[ ]D0-16 5-D1[X]| - data du ruban de led
// |[ ]D5-14 4-D2[ ]|
// |[ ]D6-12 0-D3[ ]|
// |[ ]D7-13 2-D4[ ]| LED_BUILTIN
// |[ ]D8-15 GND[X]| - masse du ruban
// |[ ]3V3 . 5V[X]| - Alim du ruban
// | +---+ |
// |_______|USB|_______|
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

#define broche 5 // broche GPIO du D1 mini sur laquelle est connectÃ© le ruban
#define bouton 2

// Nombre de led du ruban ?
#define nbpixels 38
bool buttonState = HIGH;

// Lors de la configuration de la bibliothÃ¨que NeoPixel,
// nous lui indiquons combien de pixels,
// et quelle broche utiliser pour envoyer des signaux.
Adafruit_NeoPixel pixels(nbpixels, broche, NEO_GRB + NEO_KHZ800);
// pour configurer le ruban :
// nomDuRuban (nombreDePixels, NumeroDeLaBroche, typeDeRuban)
// Les diffÃ©rents types de ruban :
// NEO_KHZ800 800 KHz bitstream (la plupart des produits Neopixel ou rÃ©fÃ©rences de LED w/WS2812)
// NEO_KHZ400 400 KHz (classic 'v1' (pas v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels cablÃ©s pour GRB bitstream (la plupart des produits Neopixel)
// NEO_RGB Pixels cablÃ©s pour RGB bitstream (v1 FLORA pixels, pas les v2)
// NEO_RGBW Pixels cablÃ©s pour RGBW bitstream (produits NeoPixel RGBW)

#define delai 30 // durÃ©e de la pause en millisecondes
Servo myservo;

void setup() {
pinMode(bouton,INPUT_PULLUP);
pixels.begin(); // INITIALISE l'object ruban NeoPixel
pixels.show(); // Ateint tout les pixels aussi vite que possible.
pixels.setBrightness(100); // met la luminositÃ© Ã 1/5 (max = 255)
Serial.begin(9600);
myservo.attach(12);
/////////////////////
//Initialisation du servo moteur
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(1);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(1);
}
//////////////////
}

void loop() {
buttonState=HIGH;
while(buttonState==HIGH){
buttonState=digitalRead(bouton); //Test du bouton
Serial.println("NOK"); //Tant qu'on appuie pas le programme attend
}
Serial.println("OK");
//int nbLap=random(3,10); //Détermination du nombre de tour
int nbLap=2;
//int nbLed=random(0,40); //Détermination de la led qui sera la derniere
int nbLed=5;
buttonState=HIGH;
for(int j=0;j<=nbLap;j++){ // Animation du ruban led où les lumières tournent
for(int i=1; i<=nbpixels; i++){
Serial.print("un");
pixels.setPixelColor(i,pixels.Color(0, 0, 255));
Serial.print("deux");
delay(30);
if(i!=0){
pixels.setPixelColor(i-1,pixels.Color(0, 0, 0));
}
if(j==nbLap && nbLed==i){
if(nbLed>0 && nbLed<=9){ //1ere zone gagnante
win(nbLed);
}
else if(nbLed>=20 && nbLed <=31){ //2eme zone gagnante
win(nbLed);
}
else{ //Zone perdante
lose(nbLed);
}
}
pixels.show(); // met Ã jour le ruban
delay(delai); // Pause
//end:
}
}
}

void win(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(0, 255, 0)); //Led verte clignote 20 fois
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); // Animation de victoire
pixels.show();
delay(200);
//goto end;
}
reward();
return;
}

void lose(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(255, 0, 0)); //Animation de défaite
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); //Led cligote rouge 20fois
pixels.show();
delay(200);
//goto end;
}
}

void reward(){
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(15);
}
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-14T15:20:40Z

Miiswitch : /* Schéma de cablage */

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

[[Fichier:Roue gourmandise.jpg|vignette]]
[[Fichier:Bascule.jpg|vignette]]
[[Fichier:Arduino roue.jpg|vignette]]

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha ben othman

==Que fait ce projet ? ==

Notre projet, la Roue de la Gourmandise, est un projet inspiré de la roue de la fortune.

Il se différencie par la façon dont on tourne la roue.

On utilise ici un bouton poussoir pour allumer une LED dans la bande de LED qui circule au fur et à mesure, et s'arrête à un moment aléatoire.

La roue est divisé en deux côtés, un gagnant et un perdant.

Lorsqu'on gagne, la deuxième partie du projet entre en place, un distributeur de bonbon. Il s'agit d'une boîte avec un récipient à bonbons. Lorsqu'on gagne, un Servo moteur s'active et fait tomber une petite quantité de bonbon dans le bas de la boîte pour que le gagnant puisse les récupérer.

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

[[Fichier:Schema de cablage.jpg|vignette]]
==Schéma de cablage==
<gallery>
Exemple.jpg|Description 1
Exemple.jpg|Description 2
</gallery>

==Code==
<pre>

// BROCHAGE
// _________________
// / D1 mini \
// |[ ]RST TX[ ]|
// |[ ]A0 -GPIO RX[ ]|
// |[ ]D0-16 5-D1[X]| - data du ruban de led
// |[ ]D5-14 4-D2[ ]|
// |[ ]D6-12 0-D3[ ]|
// |[ ]D7-13 2-D4[ ]| LED_BUILTIN
// |[ ]D8-15 GND[X]| - masse du ruban
// |[ ]3V3 . 5V[X]| - Alim du ruban
// | +---+ |
// |_______|USB|_______|
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

#define broche 5 // broche GPIO du D1 mini sur laquelle est connectÃ© le ruban
#define bouton 2

// Nombre de led du ruban ?
#define nbpixels 38
bool buttonState = HIGH;

// Lors de la configuration de la bibliothÃ¨que NeoPixel,
// nous lui indiquons combien de pixels,
// et quelle broche utiliser pour envoyer des signaux.
Adafruit_NeoPixel pixels(nbpixels, broche, NEO_GRB + NEO_KHZ800);
// pour configurer le ruban :
// nomDuRuban (nombreDePixels, NumeroDeLaBroche, typeDeRuban)
// Les diffÃ©rents types de ruban :
// NEO_KHZ800 800 KHz bitstream (la plupart des produits Neopixel ou rÃ©fÃ©rences de LED w/WS2812)
// NEO_KHZ400 400 KHz (classic 'v1' (pas v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels cablÃ©s pour GRB bitstream (la plupart des produits Neopixel)
// NEO_RGB Pixels cablÃ©s pour RGB bitstream (v1 FLORA pixels, pas les v2)
// NEO_RGBW Pixels cablÃ©s pour RGBW bitstream (produits NeoPixel RGBW)

#define delai 30 // durÃ©e de la pause en millisecondes
Servo myservo;

void setup() {
pinMode(bouton,INPUT_PULLUP);
pixels.begin(); // INITIALISE l'object ruban NeoPixel
pixels.show(); // Ateint tout les pixels aussi vite que possible.
pixels.setBrightness(100); // met la luminositÃ© Ã 1/5 (max = 255)
Serial.begin(9600);
myservo.attach(12);
/////////////////////
//Initialisation du servo moteur
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(1);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(1);
}
//////////////////
}

void loop() {
buttonState=HIGH;
while(buttonState==HIGH){
buttonState=digitalRead(bouton); //Test du bouton
Serial.println("NOK"); //Tant qu'on appuie pas le programme attend
}
Serial.println("OK");
//int nbLap=random(3,10); //Détermination du nombre de tour
int nbLap=2;
//int nbLed=random(0,40); //Détermination de la led qui sera la derniere
int nbLed=5;
buttonState=HIGH;
for(int j=0;j<=nbLap;j++){ // Animation du ruban led où les lumières tournent
for(int i=1; i<=nbpixels; i++){
Serial.print("un");
pixels.setPixelColor(i,pixels.Color(0, 0, 255));
Serial.print("deux");
delay(30);
if(i!=0){
pixels.setPixelColor(i-1,pixels.Color(0, 0, 0));
}
if(j==nbLap && nbLed==i){
if(nbLed>0 && nbLed<=9){ //1ere zone gagnante
win(nbLed);
}
else if(nbLed>=20 && nbLed <=31){ //2eme zone gagnante
win(nbLed);
}
else{ //Zone perdante
lose(nbLed);
}
}
pixels.show(); // met Ã jour le ruban
delay(delai); // Pause
//end:
}
}
}

void win(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(0, 255, 0)); //Led verte clignote 20 fois
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); // Animation de victoire
pixels.show();
delay(200);
//goto end;
}
reward();
return;
}

void lose(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(255, 0, 0)); //Animation de défaite
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); //Led cligote rouge 20fois
pixels.show();
delay(200);
//goto end;
}
}

void reward(){
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(15);
}
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-14T15:19:31Z

Miiswitch : /* Schéma de cablage */

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

[[Fichier:Roue gourmandise.jpg|vignette]]
[[Fichier:Bascule.jpg|vignette]]
[[Fichier:Arduino roue.jpg|vignette]]

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha ben othman

==Que fait ce projet ? ==

Notre projet, la Roue de la Gourmandise, est un projet inspiré de la roue de la fortune.

Il se différencie par la façon dont on tourne la roue.

On utilise ici un bouton poussoir pour allumer une LED dans la bande de LED qui circule au fur et à mesure, et s'arrête à un moment aléatoire.

La roue est divisé en deux côtés, un gagnant et un perdant.

Lorsqu'on gagne, la deuxième partie du projet entre en place, un distributeur de bonbon. Il s'agit d'une boîte avec un récipient à bonbons. Lorsqu'on gagne, un Servo moteur s'active et fait tomber une petite quantité de bonbon dans le bas de la boîte pour que le gagnant puisse les récupérer.

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

[[Fichier:Schema de cablage.jpg|vignette]]
==Schéma de cablage==

==Code==
<pre>

// BROCHAGE
// _________________
// / D1 mini \
// |[ ]RST TX[ ]|
// |[ ]A0 -GPIO RX[ ]|
// |[ ]D0-16 5-D1[X]| - data du ruban de led
// |[ ]D5-14 4-D2[ ]|
// |[ ]D6-12 0-D3[ ]|
// |[ ]D7-13 2-D4[ ]| LED_BUILTIN
// |[ ]D8-15 GND[X]| - masse du ruban
// |[ ]3V3 . 5V[X]| - Alim du ruban
// | +---+ |
// |_______|USB|_______|
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

#define broche 5 // broche GPIO du D1 mini sur laquelle est connectÃ© le ruban
#define bouton 2

// Nombre de led du ruban ?
#define nbpixels 38
bool buttonState = HIGH;

// Lors de la configuration de la bibliothÃ¨que NeoPixel,
// nous lui indiquons combien de pixels,
// et quelle broche utiliser pour envoyer des signaux.
Adafruit_NeoPixel pixels(nbpixels, broche, NEO_GRB + NEO_KHZ800);
// pour configurer le ruban :
// nomDuRuban (nombreDePixels, NumeroDeLaBroche, typeDeRuban)
// Les diffÃ©rents types de ruban :
// NEO_KHZ800 800 KHz bitstream (la plupart des produits Neopixel ou rÃ©fÃ©rences de LED w/WS2812)
// NEO_KHZ400 400 KHz (classic 'v1' (pas v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels cablÃ©s pour GRB bitstream (la plupart des produits Neopixel)
// NEO_RGB Pixels cablÃ©s pour RGB bitstream (v1 FLORA pixels, pas les v2)
// NEO_RGBW Pixels cablÃ©s pour RGBW bitstream (produits NeoPixel RGBW)

#define delai 30 // durÃ©e de la pause en millisecondes
Servo myservo;

void setup() {
pinMode(bouton,INPUT_PULLUP);
pixels.begin(); // INITIALISE l'object ruban NeoPixel
pixels.show(); // Ateint tout les pixels aussi vite que possible.
pixels.setBrightness(100); // met la luminositÃ© Ã 1/5 (max = 255)
Serial.begin(9600);
myservo.attach(12);
/////////////////////
//Initialisation du servo moteur
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(1);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(1);
}
//////////////////
}

void loop() {
buttonState=HIGH;
while(buttonState==HIGH){
buttonState=digitalRead(bouton); //Test du bouton
Serial.println("NOK"); //Tant qu'on appuie pas le programme attend
}
Serial.println("OK");
//int nbLap=random(3,10); //Détermination du nombre de tour
int nbLap=2;
//int nbLed=random(0,40); //Détermination de la led qui sera la derniere
int nbLed=5;
buttonState=HIGH;
for(int j=0;j<=nbLap;j++){ // Animation du ruban led où les lumières tournent
for(int i=1; i<=nbpixels; i++){
Serial.print("un");
pixels.setPixelColor(i,pixels.Color(0, 0, 255));
Serial.print("deux");
delay(30);
if(i!=0){
pixels.setPixelColor(i-1,pixels.Color(0, 0, 0));
}
if(j==nbLap && nbLed==i){
if(nbLed>0 && nbLed<=9){ //1ere zone gagnante
win(nbLed);
}
else if(nbLed>=20 && nbLed <=31){ //2eme zone gagnante
win(nbLed);
}
else{ //Zone perdante
lose(nbLed);
}
}
pixels.show(); // met Ã jour le ruban
delay(delai); // Pause
//end:
}
}
}

void win(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(0, 255, 0)); //Led verte clignote 20 fois
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); // Animation de victoire
pixels.show();
delay(200);
//goto end;
}
reward();
return;
}

void lose(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(255, 0, 0)); //Animation de défaite
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); //Led cligote rouge 20fois
pixels.show();
delay(200);
//goto end;
}
}

void reward(){
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(15);
}
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-14T15:19:12Z

Miiswitch : /* Schéma de cablage */

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

[[Fichier:Roue gourmandise.jpg|vignette]]
[[Fichier:Bascule.jpg|vignette]]
[[Fichier:Arduino roue.jpg|vignette]]

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha ben othman

==Que fait ce projet ? ==

Notre projet, la Roue de la Gourmandise, est un projet inspiré de la roue de la fortune.

Il se différencie par la façon dont on tourne la roue.

On utilise ici un bouton poussoir pour allumer une LED dans la bande de LED qui circule au fur et à mesure, et s'arrête à un moment aléatoire.

La roue est divisé en deux côtés, un gagnant et un perdant.

Lorsqu'on gagne, la deuxième partie du projet entre en place, un distributeur de bonbon. Il s'agit d'une boîte avec un récipient à bonbons. Lorsqu'on gagne, un Servo moteur s'active et fait tomber une petite quantité de bonbon dans le bas de la boîte pour que le gagnant puisse les récupérer.

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

==Schéma de cablage==
[[Fichier:Schema de cablage.jpg|vignette]]

==Code==
<pre>

// BROCHAGE
// _________________
// / D1 mini \
// |[ ]RST TX[ ]|
// |[ ]A0 -GPIO RX[ ]|
// |[ ]D0-16 5-D1[X]| - data du ruban de led
// |[ ]D5-14 4-D2[ ]|
// |[ ]D6-12 0-D3[ ]|
// |[ ]D7-13 2-D4[ ]| LED_BUILTIN
// |[ ]D8-15 GND[X]| - masse du ruban
// |[ ]3V3 . 5V[X]| - Alim du ruban
// | +---+ |
// |_______|USB|_______|
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

#define broche 5 // broche GPIO du D1 mini sur laquelle est connectÃ© le ruban
#define bouton 2

// Nombre de led du ruban ?
#define nbpixels 38
bool buttonState = HIGH;

// Lors de la configuration de la bibliothÃ¨que NeoPixel,
// nous lui indiquons combien de pixels,
// et quelle broche utiliser pour envoyer des signaux.
Adafruit_NeoPixel pixels(nbpixels, broche, NEO_GRB + NEO_KHZ800);
// pour configurer le ruban :
// nomDuRuban (nombreDePixels, NumeroDeLaBroche, typeDeRuban)
// Les diffÃ©rents types de ruban :
// NEO_KHZ800 800 KHz bitstream (la plupart des produits Neopixel ou rÃ©fÃ©rences de LED w/WS2812)
// NEO_KHZ400 400 KHz (classic 'v1' (pas v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels cablÃ©s pour GRB bitstream (la plupart des produits Neopixel)
// NEO_RGB Pixels cablÃ©s pour RGB bitstream (v1 FLORA pixels, pas les v2)
// NEO_RGBW Pixels cablÃ©s pour RGBW bitstream (produits NeoPixel RGBW)

#define delai 30 // durÃ©e de la pause en millisecondes
Servo myservo;

void setup() {
pinMode(bouton,INPUT_PULLUP);
pixels.begin(); // INITIALISE l'object ruban NeoPixel
pixels.show(); // Ateint tout les pixels aussi vite que possible.
pixels.setBrightness(100); // met la luminositÃ© Ã 1/5 (max = 255)
Serial.begin(9600);
myservo.attach(12);
/////////////////////
//Initialisation du servo moteur
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(1);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(1);
}
//////////////////
}

void loop() {
buttonState=HIGH;
while(buttonState==HIGH){
buttonState=digitalRead(bouton); //Test du bouton
Serial.println("NOK"); //Tant qu'on appuie pas le programme attend
}
Serial.println("OK");
//int nbLap=random(3,10); //Détermination du nombre de tour
int nbLap=2;
//int nbLed=random(0,40); //Détermination de la led qui sera la derniere
int nbLed=5;
buttonState=HIGH;
for(int j=0;j<=nbLap;j++){ // Animation du ruban led où les lumières tournent
for(int i=1; i<=nbpixels; i++){
Serial.print("un");
pixels.setPixelColor(i,pixels.Color(0, 0, 255));
Serial.print("deux");
delay(30);
if(i!=0){
pixels.setPixelColor(i-1,pixels.Color(0, 0, 0));
}
if(j==nbLap && nbLed==i){
if(nbLed>0 && nbLed<=9){ //1ere zone gagnante
win(nbLed);
}
else if(nbLed>=20 && nbLed <=31){ //2eme zone gagnante
win(nbLed);
}
else{ //Zone perdante
lose(nbLed);
}
}
pixels.show(); // met Ã jour le ruban
delay(delai); // Pause
//end:
}
}
}

void win(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(0, 255, 0)); //Led verte clignote 20 fois
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); // Animation de victoire
pixels.show();
delay(200);
//goto end;
}
reward();
return;
}

void lose(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(255, 0, 0)); //Animation de défaite
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); //Led cligote rouge 20fois
pixels.show();
delay(200);
//goto end;
}
}

void reward(){
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(15);
}
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

Fichier:Schema de cablage.jpg

2022-01-14T15:18:51Z

Miiswitch :

Schéma de cablage fait avec le logiciel Fritzing

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-14T15:17:29Z

Miiswitch :

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

[[Fichier:Roue gourmandise.jpg|vignette]]
[[Fichier:Bascule.jpg|vignette]]
[[Fichier:Arduino roue.jpg|vignette]]

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha ben othman

==Que fait ce projet ? ==

Notre projet, la Roue de la Gourmandise, est un projet inspiré de la roue de la fortune.

Il se différencie par la façon dont on tourne la roue.

On utilise ici un bouton poussoir pour allumer une LED dans la bande de LED qui circule au fur et à mesure, et s'arrête à un moment aléatoire.

La roue est divisé en deux côtés, un gagnant et un perdant.

Lorsqu'on gagne, la deuxième partie du projet entre en place, un distributeur de bonbon. Il s'agit d'une boîte avec un récipient à bonbons. Lorsqu'on gagne, un Servo moteur s'active et fait tomber une petite quantité de bonbon dans le bas de la boîte pour que le gagnant puisse les récupérer.

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

==Schéma de cablage==

==Code==
<pre>

// BROCHAGE
// _________________
// / D1 mini \
// |[ ]RST TX[ ]|
// |[ ]A0 -GPIO RX[ ]|
// |[ ]D0-16 5-D1[X]| - data du ruban de led
// |[ ]D5-14 4-D2[ ]|
// |[ ]D6-12 0-D3[ ]|
// |[ ]D7-13 2-D4[ ]| LED_BUILTIN
// |[ ]D8-15 GND[X]| - masse du ruban
// |[ ]3V3 . 5V[X]| - Alim du ruban
// | +---+ |
// |_______|USB|_______|
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

#define broche 5 // broche GPIO du D1 mini sur laquelle est connectÃ© le ruban
#define bouton 2

// Nombre de led du ruban ?
#define nbpixels 38
bool buttonState = HIGH;

// Lors de la configuration de la bibliothÃ¨que NeoPixel,
// nous lui indiquons combien de pixels,
// et quelle broche utiliser pour envoyer des signaux.
Adafruit_NeoPixel pixels(nbpixels, broche, NEO_GRB + NEO_KHZ800);
// pour configurer le ruban :
// nomDuRuban (nombreDePixels, NumeroDeLaBroche, typeDeRuban)
// Les diffÃ©rents types de ruban :
// NEO_KHZ800 800 KHz bitstream (la plupart des produits Neopixel ou rÃ©fÃ©rences de LED w/WS2812)
// NEO_KHZ400 400 KHz (classic 'v1' (pas v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels cablÃ©s pour GRB bitstream (la plupart des produits Neopixel)
// NEO_RGB Pixels cablÃ©s pour RGB bitstream (v1 FLORA pixels, pas les v2)
// NEO_RGBW Pixels cablÃ©s pour RGBW bitstream (produits NeoPixel RGBW)

#define delai 30 // durÃ©e de la pause en millisecondes
Servo myservo;

void setup() {
pinMode(bouton,INPUT_PULLUP);
pixels.begin(); // INITIALISE l'object ruban NeoPixel
pixels.show(); // Ateint tout les pixels aussi vite que possible.
pixels.setBrightness(100); // met la luminositÃ© Ã 1/5 (max = 255)
Serial.begin(9600);
myservo.attach(12);
/////////////////////
//Initialisation du servo moteur
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(1);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(1);
}
//////////////////
}

void loop() {
buttonState=HIGH;
while(buttonState==HIGH){
buttonState=digitalRead(bouton); //Test du bouton
Serial.println("NOK"); //Tant qu'on appuie pas le programme attend
}
Serial.println("OK");
//int nbLap=random(3,10); //Détermination du nombre de tour
int nbLap=2;
//int nbLed=random(0,40); //Détermination de la led qui sera la derniere
int nbLed=5;
buttonState=HIGH;
for(int j=0;j<=nbLap;j++){ // Animation du ruban led où les lumières tournent
for(int i=1; i<=nbpixels; i++){
Serial.print("un");
pixels.setPixelColor(i,pixels.Color(0, 0, 255));
Serial.print("deux");
delay(30);
if(i!=0){
pixels.setPixelColor(i-1,pixels.Color(0, 0, 0));
}
if(j==nbLap && nbLed==i){
if(nbLed>0 && nbLed<=9){ //1ere zone gagnante
win(nbLed);
}
else if(nbLed>=20 && nbLed <=31){ //2eme zone gagnante
win(nbLed);
}
else{ //Zone perdante
lose(nbLed);
}
}
pixels.show(); // met Ã jour le ruban
delay(delai); // Pause
//end:
}
}
}

void win(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(0, 255, 0)); //Led verte clignote 20 fois
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); // Animation de victoire
pixels.show();
delay(200);
//goto end;
}
reward();
return;
}

void lose(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(255, 0, 0)); //Animation de défaite
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); //Led cligote rouge 20fois
pixels.show();
delay(200);
//goto end;
}
}

void reward(){
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(15);
}
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-14T14:19:10Z

Miiswitch :

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

[[Fichier:Roue gourmandise.jpg|vignette]]
[[Fichier:Bascule.jpg|vignette]]
[[Fichier:Arduino roue.jpg|vignette]]

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha ben othman

==Que fait ce projet ? ==

Notre projet, la Roue de la Gourmandise, est un projet inspiré de la roue de la fortune.

Il se différencie par la façon dont on tourne la roue.

On utilise ici un bouton poussoir pour allumer une LED dans la bande de LED qui circule au fur et à mesure, et s'arrête à un moment aléatoire.

La roue est divisé en deux côtés, un gagnant et un perdant.

Lorsqu'on gagne, la deuxième partie du projet entre en place, un distributeur de bonbon. Il s'agit d'une boîte avec un récipient à bonbons. Lorsqu'on gagne, un Servo moteur s'active et fait tomber une petite quantité de bonbon dans le bas de la boîte pour que le gagnant puisse les récupérer.

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

==Code==
<pre>

// BROCHAGE
// _________________
// / D1 mini \
// |[ ]RST TX[ ]|
// |[ ]A0 -GPIO RX[ ]|
// |[ ]D0-16 5-D1[X]| - data du ruban de led
// |[ ]D5-14 4-D2[ ]|
// |[ ]D6-12 0-D3[ ]|
// |[ ]D7-13 2-D4[ ]| LED_BUILTIN
// |[ ]D8-15 GND[X]| - masse du ruban
// |[ ]3V3 . 5V[X]| - Alim du ruban
// | +---+ |
// |_______|USB|_______|
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

#define broche 5 // broche GPIO du D1 mini sur laquelle est connectÃ© le ruban
#define bouton 2

// Nombre de led du ruban ?
#define nbpixels 38
bool buttonState = HIGH;

// Lors de la configuration de la bibliothÃ¨que NeoPixel,
// nous lui indiquons combien de pixels,
// et quelle broche utiliser pour envoyer des signaux.
Adafruit_NeoPixel pixels(nbpixels, broche, NEO_GRB + NEO_KHZ800);
// pour configurer le ruban :
// nomDuRuban (nombreDePixels, NumeroDeLaBroche, typeDeRuban)
// Les diffÃ©rents types de ruban :
// NEO_KHZ800 800 KHz bitstream (la plupart des produits Neopixel ou rÃ©fÃ©rences de LED w/WS2812)
// NEO_KHZ400 400 KHz (classic 'v1' (pas v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels cablÃ©s pour GRB bitstream (la plupart des produits Neopixel)
// NEO_RGB Pixels cablÃ©s pour RGB bitstream (v1 FLORA pixels, pas les v2)
// NEO_RGBW Pixels cablÃ©s pour RGBW bitstream (produits NeoPixel RGBW)

#define delai 30 // durÃ©e de la pause en millisecondes
Servo myservo;

void setup() {
pinMode(bouton,INPUT_PULLUP);
pixels.begin(); // INITIALISE l'object ruban NeoPixel
pixels.show(); // Ateint tout les pixels aussi vite que possible.
pixels.setBrightness(100); // met la luminositÃ© Ã 1/5 (max = 255)
Serial.begin(9600);
myservo.attach(12);
/////////////////////
//Initialisation du servo moteur
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(1);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(1);
}
//////////////////
}

void loop() {
buttonState=HIGH;
while(buttonState==HIGH){
buttonState=digitalRead(bouton); //Test du bouton
Serial.println("NOK"); //Tant qu'on appuie pas le programme attend
}
Serial.println("OK");
//int nbLap=random(3,10); //Détermination du nombre de tour
int nbLap=2;
//int nbLed=random(0,40); //Détermination de la led qui sera la derniere
int nbLed=5;
buttonState=HIGH;
for(int j=0;j<=nbLap;j++){ // Animation du ruban led où les lumières tournent
for(int i=1; i<=nbpixels; i++){
Serial.print("un");
pixels.setPixelColor(i,pixels.Color(0, 0, 255));
Serial.print("deux");
delay(30);
if(i!=0){
pixels.setPixelColor(i-1,pixels.Color(0, 0, 0));
}
if(j==nbLap && nbLed==i){
if(nbLed>0 && nbLed<=9){ //1ere zone gagnante
win(nbLed);
}
else if(nbLed>=20 && nbLed <=31){ //2eme zone gagnante
win(nbLed);
}
else{ //Zone perdante
lose(nbLed);
}
}
pixels.show(); // met Ã jour le ruban
delay(delai); // Pause
//end:
}
}
}

void win(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(0, 255, 0)); //Led verte clignote 20 fois
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); // Animation de victoire
pixels.show();
delay(200);
//goto end;
}
reward();
return;
}

void lose(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(255, 0, 0)); //Animation de défaite
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); //Led cligote rouge 20fois
pixels.show();
delay(200);
//goto end;
}
}

void reward(){
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(15);
}
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

Fichier:Arduino roue.jpg

2022-01-14T14:18:55Z

Miiswitch :

arduino

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-14T14:17:34Z

Miiswitch :

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

[[Fichier:Roue gourmandise.jpg|vignette]]
[[Fichier:Bascule.jpg|vignette]]

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha ben othman

==Que fait ce projet ? ==

Notre projet, la Roue de la Gourmandise, est un projet inspiré de la roue de la fortune.

Il se différencie par la façon dont on tourne la roue.

On utilise ici un bouton poussoir pour allumer une LED dans la bande de LED qui circule au fur et à mesure, et s'arrête à un moment aléatoire.

La roue est divisé en deux côtés, un gagnant et un perdant.

Lorsqu'on gagne, la deuxième partie du projet entre en place, un distributeur de bonbon. Il s'agit d'une boîte avec un récipient à bonbons. Lorsqu'on gagne, un Servo moteur s'active et fait tomber une petite quantité de bonbon dans le bas de la boîte pour que le gagnant puisse les récupérer.

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

==Code==
<pre>

// BROCHAGE
// _________________
// / D1 mini \
// |[ ]RST TX[ ]|
// |[ ]A0 -GPIO RX[ ]|
// |[ ]D0-16 5-D1[X]| - data du ruban de led
// |[ ]D5-14 4-D2[ ]|
// |[ ]D6-12 0-D3[ ]|
// |[ ]D7-13 2-D4[ ]| LED_BUILTIN
// |[ ]D8-15 GND[X]| - masse du ruban
// |[ ]3V3 . 5V[X]| - Alim du ruban
// | +---+ |
// |_______|USB|_______|
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

#define broche 5 // broche GPIO du D1 mini sur laquelle est connectÃ© le ruban
#define bouton 2

// Nombre de led du ruban ?
#define nbpixels 38
bool buttonState = HIGH;

// Lors de la configuration de la bibliothÃ¨que NeoPixel,
// nous lui indiquons combien de pixels,
// et quelle broche utiliser pour envoyer des signaux.
Adafruit_NeoPixel pixels(nbpixels, broche, NEO_GRB + NEO_KHZ800);
// pour configurer le ruban :
// nomDuRuban (nombreDePixels, NumeroDeLaBroche, typeDeRuban)
// Les diffÃ©rents types de ruban :
// NEO_KHZ800 800 KHz bitstream (la plupart des produits Neopixel ou rÃ©fÃ©rences de LED w/WS2812)
// NEO_KHZ400 400 KHz (classic 'v1' (pas v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels cablÃ©s pour GRB bitstream (la plupart des produits Neopixel)
// NEO_RGB Pixels cablÃ©s pour RGB bitstream (v1 FLORA pixels, pas les v2)
// NEO_RGBW Pixels cablÃ©s pour RGBW bitstream (produits NeoPixel RGBW)

#define delai 30 // durÃ©e de la pause en millisecondes
Servo myservo;

void setup() {
pinMode(bouton,INPUT_PULLUP);
pixels.begin(); // INITIALISE l'object ruban NeoPixel
pixels.show(); // Ateint tout les pixels aussi vite que possible.
pixels.setBrightness(100); // met la luminositÃ© Ã 1/5 (max = 255)
Serial.begin(9600);
myservo.attach(12);
/////////////////////
//Initialisation du servo moteur
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(1);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(1);
}
//////////////////
}

void loop() {
buttonState=HIGH;
while(buttonState==HIGH){
buttonState=digitalRead(bouton); //Test du bouton
Serial.println("NOK"); //Tant qu'on appuie pas le programme attend
}
Serial.println("OK");
//int nbLap=random(3,10); //Détermination du nombre de tour
int nbLap=2;
//int nbLed=random(0,40); //Détermination de la led qui sera la derniere
int nbLed=5;
buttonState=HIGH;
for(int j=0;j<=nbLap;j++){ // Animation du ruban led où les lumières tournent
for(int i=1; i<=nbpixels; i++){
Serial.print("un");
pixels.setPixelColor(i,pixels.Color(0, 0, 255));
Serial.print("deux");
delay(30);
if(i!=0){
pixels.setPixelColor(i-1,pixels.Color(0, 0, 0));
}
if(j==nbLap && nbLed==i){
if(nbLed>0 && nbLed<=9){ //1ere zone gagnante
win(nbLed);
}
else if(nbLed>=20 && nbLed <=31){ //2eme zone gagnante
win(nbLed);
}
else{ //Zone perdante
lose(nbLed);
}
}
pixels.show(); // met Ã jour le ruban
delay(delai); // Pause
//end:
}
}
}

void win(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(0, 255, 0)); //Led verte clignote 20 fois
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); // Animation de victoire
pixels.show();
delay(200);
//goto end;
}
reward();
return;
}

void lose(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(255, 0, 0)); //Animation de défaite
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); //Led cligote rouge 20fois
pixels.show();
delay(200);
//goto end;
}
}

void reward(){
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(15);
}
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

Fichier:Roue gourmandise.jpg

2022-01-14T14:17:26Z

Miiswitch :

la roue de la gourmandise

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-14T14:16:34Z

Miiswitch :

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

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha ben othman

==Que fait ce projet ? ==

Notre projet, la Roue de la Gourmandise, est un projet inspiré de la roue de la fortune.

Il se différencie par la façon dont on tourne la roue.

On utilise ici un bouton poussoir pour allumer une LED dans la bande de LED qui circule au fur et à mesure, et s'arrête à un moment aléatoire.

La roue est divisé en deux côtés, un gagnant et un perdant.

Lorsqu'on gagne, la deuxième partie du projet entre en place, un distributeur de bonbon. Il s'agit d'une boîte avec un récipient à bonbons. Lorsqu'on gagne, un Servo moteur s'active et fait tomber une petite quantité de bonbon dans le bas de la boîte pour que le gagnant puisse les récupérer.

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

==Code==
<pre>

// BROCHAGE
// _________________
// / D1 mini \
// |[ ]RST TX[ ]|
// |[ ]A0 -GPIO RX[ ]|
// |[ ]D0-16 5-D1[X]| - data du ruban de led
// |[ ]D5-14 4-D2[ ]|
// |[ ]D6-12 0-D3[ ]|
// |[ ]D7-13 2-D4[ ]| LED_BUILTIN
// |[ ]D8-15 GND[X]| - masse du ruban
// |[ ]3V3 . 5V[X]| - Alim du ruban
// | +---+ |
// |_______|USB|_______|
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

#define broche 5 // broche GPIO du D1 mini sur laquelle est connectÃ© le ruban
#define bouton 2

// Nombre de led du ruban ?
#define nbpixels 38
bool buttonState = HIGH;

// Lors de la configuration de la bibliothÃ¨que NeoPixel,
// nous lui indiquons combien de pixels,
// et quelle broche utiliser pour envoyer des signaux.
Adafruit_NeoPixel pixels(nbpixels, broche, NEO_GRB + NEO_KHZ800);
// pour configurer le ruban :
// nomDuRuban (nombreDePixels, NumeroDeLaBroche, typeDeRuban)
// Les diffÃ©rents types de ruban :
// NEO_KHZ800 800 KHz bitstream (la plupart des produits Neopixel ou rÃ©fÃ©rences de LED w/WS2812)
// NEO_KHZ400 400 KHz (classic 'v1' (pas v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels cablÃ©s pour GRB bitstream (la plupart des produits Neopixel)
// NEO_RGB Pixels cablÃ©s pour RGB bitstream (v1 FLORA pixels, pas les v2)
// NEO_RGBW Pixels cablÃ©s pour RGBW bitstream (produits NeoPixel RGBW)

#define delai 30 // durÃ©e de la pause en millisecondes
Servo myservo;

void setup() {
pinMode(bouton,INPUT_PULLUP);
pixels.begin(); // INITIALISE l'object ruban NeoPixel
pixels.show(); // Ateint tout les pixels aussi vite que possible.
pixels.setBrightness(100); // met la luminositÃ© Ã 1/5 (max = 255)
Serial.begin(9600);
myservo.attach(12);
/////////////////////
//Initialisation du servo moteur
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(1);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(1);
}
//////////////////
}

void loop() {
buttonState=HIGH;
while(buttonState==HIGH){
buttonState=digitalRead(bouton); //Test du bouton
Serial.println("NOK"); //Tant qu'on appuie pas le programme attend
}
Serial.println("OK");
//int nbLap=random(3,10); //Détermination du nombre de tour
int nbLap=2;
//int nbLed=random(0,40); //Détermination de la led qui sera la derniere
int nbLed=5;
buttonState=HIGH;
for(int j=0;j<=nbLap;j++){ // Animation du ruban led où les lumières tournent
for(int i=1; i<=nbpixels; i++){
Serial.print("un");
pixels.setPixelColor(i,pixels.Color(0, 0, 255));
Serial.print("deux");
delay(30);
if(i!=0){
pixels.setPixelColor(i-1,pixels.Color(0, 0, 0));
}
if(j==nbLap && nbLed==i){
if(nbLed>0 && nbLed<=9){ //1ere zone gagnante
win(nbLed);
}
else if(nbLed>=20 && nbLed <=31){ //2eme zone gagnante
win(nbLed);
}
else{ //Zone perdante
lose(nbLed);
}
}
pixels.show(); // met Ã jour le ruban
delay(delai); // Pause
//end:
}
}
}

void win(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(0, 255, 0)); //Led verte clignote 20 fois
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); // Animation de victoire
pixels.show();
delay(200);
//goto end;
}
reward();
return;
}

void lose(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(255, 0, 0)); //Animation de défaite
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); //Led cligote rouge 20fois
pixels.show();
delay(200);
//goto end;
}
}

void reward(){
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(15);
}
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

Fichier:Bascule.jpg

2022-01-14T14:16:06Z

Miiswitch :

bascule à bonbons

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-14T14:12:16Z

Miiswitch :

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

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha ben othman

==Que fait ce projet ? ==

Notre projet, la Roue de la Gourmandise, est un projet inspiré de la roue de la fortune.

Il se différencie par la façon dont on tourne la roue.

On utilise ici un bouton poussoir pour allumer une LED dans la bande de LED qui circule au fur et à mesure, et s'arrête à un moment aléatoire.

La roue est divisé en deux côtés, un gagnant et un perdant.

Lorsqu'on gagne, la deuxième partie du projet entre en place, un distributeur de bonbon. Il s'agit d'une boîte avec un récipient à bonbons. Lorsqu'on gagne, un Servo moteur s'active et fait tomber une petite quantité de bonbon dans le bas de la boîte pour que le gagnant puisse les récupérer.

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

==Code==
<pre>

// BROCHAGE
// _________________
// / D1 mini \
// |[ ]RST TX[ ]|
// |[ ]A0 -GPIO RX[ ]|
// |[ ]D0-16 5-D1[X]| - data du ruban de led
// |[ ]D5-14 4-D2[ ]|
// |[ ]D6-12 0-D3[ ]|
// |[ ]D7-13 2-D4[ ]| LED_BUILTIN
// |[ ]D8-15 GND[X]| - masse du ruban
// |[ ]3V3 . 5V[X]| - Alim du ruban
// | +---+ |
// |_______|USB|_______|
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

#define broche 5 // broche GPIO du D1 mini sur laquelle est connectÃ© le ruban
#define bouton 2

// Nombre de led du ruban ?
#define nbpixels 38
bool buttonState = HIGH;

// Lors de la configuration de la bibliothÃ¨que NeoPixel,
// nous lui indiquons combien de pixels,
// et quelle broche utiliser pour envoyer des signaux.
Adafruit_NeoPixel pixels(nbpixels, broche, NEO_GRB + NEO_KHZ800);
// pour configurer le ruban :
// nomDuRuban (nombreDePixels, NumeroDeLaBroche, typeDeRuban)
// Les diffÃ©rents types de ruban :
// NEO_KHZ800 800 KHz bitstream (la plupart des produits Neopixel ou rÃ©fÃ©rences de LED w/WS2812)
// NEO_KHZ400 400 KHz (classic 'v1' (pas v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels cablÃ©s pour GRB bitstream (la plupart des produits Neopixel)
// NEO_RGB Pixels cablÃ©s pour RGB bitstream (v1 FLORA pixels, pas les v2)
// NEO_RGBW Pixels cablÃ©s pour RGBW bitstream (produits NeoPixel RGBW)

#define delai 30 // durÃ©e de la pause en millisecondes
Servo myservo;

void setup() {
pinMode(bouton,INPUT_PULLUP);
pixels.begin(); // INITIALISE l'object ruban NeoPixel
pixels.show(); // Ateint tout les pixels aussi vite que possible.
pixels.setBrightness(100); // met la luminositÃ© Ã 1/5 (max = 255)
Serial.begin(9600);
myservo.attach(12);
/////////////////////
//Initialisation du servo moteur
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(1);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(1);
}
//////////////////
}

void loop() {
buttonState=HIGH;
while(buttonState==HIGH){
buttonState=digitalRead(bouton); //Test du bouton
Serial.println("NOK"); //Tant qu'on appuie pas le programme attend
}
Serial.println("OK");
//int nbLap=random(3,10); //Détermination du nombre de tour
int nbLap=2;
//int nbLed=random(0,40); //Détermination de la led qui sera la derniere
int nbLed=5;
buttonState=HIGH;
for(int j=0;j<=nbLap;j++){ // Animation du ruban led où les lumières tournent
for(int i=1; i<=nbpixels; i++){
Serial.print("un");
pixels.setPixelColor(i,pixels.Color(0, 0, 255));
Serial.print("deux");
delay(30);
if(i!=0){
pixels.setPixelColor(i-1,pixels.Color(0, 0, 0));
}
if(j==nbLap && nbLed==i){
if(nbLed>0 && nbLed<=9){ //1ere zone gagnante
win(nbLed);
}
else if(nbLed>=20 && nbLed <=31){ //2eme zone gagnante
win(nbLed);
}
else{ //Zone perdante
lose(nbLed);
}
}
pixels.show(); // met Ã jour le ruban
delay(delai); // Pause
//end:
}
}
}

void win(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(0, 255, 0)); //Led verte clignote 20 fois
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); // Animation de victoire
pixels.show();
delay(200);
//goto end;
}
reward();
return;
}

void lose(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(255, 0, 0)); //Animation de défaite
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); //Led cligote rouge 20fois
pixels.show();
delay(200);
//goto end;
}
}

void reward(){
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(15);
}
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-14T14:11:04Z

Miiswitch :

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

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha ben othman

==Que fait ce projet ? ==

Notre projet, la Roue de la Gourmandise, est un projet inspiré de la roue de la fortune.

Il se différencie par la façon dont on tourne la roue.

On utilise ici un bouton poussoir pour allumer une LED dans la bande de LED qui circule au fur et à mesure, et s'arrête à un moment aléatoire.

La roue est divisé en deux côtés, un gagnant et un perdant.

Lorsqu'on gagne, la deuxième partie du projet entre en place, un distributeur de bonbon. Il s'agit d'une boîte avec un récipient à bonbons. Lorsqu'on gagne, un Servo moteur s'active et fait tomber une petite quantité de bonbon dans le bas de la boîte pour que le gagnant puisse les récupérer.

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

==Code==
<pre>

// BROCHAGE
// _________________
// / D1 mini \
// |[ ]RST TX[ ]|
// |[ ]A0 -GPIO RX[ ]|
// |[ ]D0-16 5-D1[X]| - data du ruban de led
// |[ ]D5-14 4-D2[ ]|
// |[ ]D6-12 0-D3[ ]|
// |[ ]D7-13 2-D4[ ]| LED_BUILTIN
// |[ ]D8-15 GND[X]| - masse du ruban
// |[ ]3V3 . 5V[X]| - Alim du ruban
// | +---+ |
// |_______|USB|_______|
#include <Adafruit_NeoPixel.h>
#include <Servo.h>

#define broche 5 // broche GPIO du D1 mini sur laquelle est connectÃ© le ruban
#define bouton 2

// Nombre de led du ruban ?
#define nbpixels 38
bool buttonState = HIGH;

// Lors de la configuration de la bibliothÃ¨que NeoPixel,
// nous lui indiquons combien de pixels,
// et quelle broche utiliser pour envoyer des signaux.
Adafruit_NeoPixel pixels(nbpixels, broche, NEO_GRB + NEO_KHZ800);
// pour configurer le ruban :
// nomDuRuban (nombreDePixels, NumeroDeLaBroche, typeDeRuban)
// Les diffÃ©rents types de ruban :
// NEO_KHZ800 800 KHz bitstream (la plupart des produits Neopixel ou rÃ©fÃ©rences de LED w/WS2812)
// NEO_KHZ400 400 KHz (classic 'v1' (pas v2) FLORA pixels, drivers WS2811)
// NEO_GRB Pixels cablÃ©s pour GRB bitstream (la plupart des produits Neopixel)
// NEO_RGB Pixels cablÃ©s pour RGB bitstream (v1 FLORA pixels, pas les v2)
// NEO_RGBW Pixels cablÃ©s pour RGBW bitstream (produits NeoPixel RGBW)

#define delai 30 // durÃ©e de la pause en millisecondes
Servo myservo;

void setup() {
pinMode(bouton,INPUT_PULLUP);
pixels.begin(); // INITIALISE l'object ruban NeoPixel
pixels.show(); // Ateint tout les pixels aussi vite que possible.
pixels.setBrightness(100); // met la luminositÃ© Ã 1/5 (max = 255)
Serial.begin(9600);
myservo.attach(12);
/////////////////////
//Initialisation du servo moteur
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(1);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(1);
}
//////////////////
}

void loop() {
buttonState=HIGH;
while(buttonState==HIGH){
buttonState=digitalRead(bouton); //Test du bouton
Serial.println("NOK"); //Tant qu'on appuie pas le programme attend
}
Serial.println("OK");
//int nbLap=random(3,10); //Détermination du nombre de tour
int nbLap=2;
//int nbLed=random(0,40); //Détermination de la led qui sera la derniere
int nbLed=5;
buttonState=HIGH;
for(int j=0;j<=nbLap;j++){ // Animation du ruban led où les lumières tournent
for(int i=1; i<=nbpixels; i++){
Serial.print("un");
pixels.setPixelColor(i,pixels.Color(0, 0, 255));
Serial.print("deux");
delay(30);
if(i!=0){
pixels.setPixelColor(i-1,pixels.Color(0, 0, 0));
}
if(j==nbLap && nbLed==i){
if(nbLed>0 && nbLed<=9){ //1ere zone gagnante
win(nbLed);
}
else if(nbLed>=20 && nbLed <=30){ //2eme zone gagnante
win(nbLed);
}
else{ //Zone perdante
lose(nbLed);
}
}
pixels.show(); // met Ã jour le ruban
delay(delai); // Pause
//end:
}
}
}

void win(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(0, 255, 0)); //Led verte clignote 20 fois
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); // Animation de victoire
pixels.show();
delay(200);
//goto end;
}
reward();
return;
}

void lose(int i){
for(int j=0;j<=20;j++){
pixels.setPixelColor(i,pixels.Color(255, 0, 0)); //Animation de défaite
pixels.show();
delay(200);
pixels.setPixelColor(i,pixels.Color(0, 0, 0)); //Led cligote rouge 20fois
pixels.show();
delay(200);
//goto end;
}
}

void reward(){
int pos=190;
for (pos = 190; pos >=20; pos -= 1) {
// in steps of 1 degree
myservo.write(pos);
delay(15);
}
for (pos = 20; pos <=190; pos += 1) {
myservo.write(pos);
delay(15);
}
}
</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-13T15:24:27Z

Miiswitch :

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-13T15:24:12Z

Miiswitch :

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-13T15:20:58Z

Miiswitch : /* Que fait ce projet ? */

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-13T15:19:26Z

Miiswitch : /* Que fait ce projet ? */

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-13T15:19:02Z

Miiswitch : /* Que fait ce projet ? */

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-13T15:15:27Z

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

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

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha ben othman

==Que fait ce projet ? ==

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha ben othman

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

==Code==
<pre>
ici je pose mon code documenté !
</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-13T15:15:18Z

Miiswitch : /* Que fait ce projet ? */

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

==Que fait ce projet ? ==

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha ben othman

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton
* Bouteille en plastique
* Des bonbons capables de passer dans un goulot

==Code==
<pre>
ici je pose mon code documenté !
</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-13T15:15:00Z

Miiswitch : /* Liste des composants */

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-13T15:13:49Z

Miiswitch : /* Liste des composants */

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

==Que fait ce projet ? ==

Arthur CHEVALIER

Clémence JAMBOU

Antonin LACLAUTRE

Maha ben othman

==Liste des composants==

* Carte Arduino D1 Mini
* Servo moteur
* Câbles
* Cable USB
* Résistance 660 ohms
* bouton poussoir
* bande LED
* Carton

==Code==
<pre>
ici je pose mon code documenté !
</pre>

==Catégories==

[[Catégorie:Enib2022]]

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-13T08:56:48Z

Miiswitch :

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-13T08:56:28Z

Miiswitch :

ENIB 2022 - groupe A : Roue de la gourmandise

2022-01-07T14:34:24Z

Miiswitch : Page créée avec « ==photo de l'équipe== 600px ==Que fait ce projet ? == ==Liste des composants== * composant 1 * composant 2 * ... ==Code== <pre> ici je p... »

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

==Que fait ce projet ? ==

==Liste des composants==

* composant 1
* composant 2
* ...

==Code==
<pre>
ici je pose mon code documenté !
</pre>

==Catégories==

[[Catégorie:Enib2022]]