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

L'arbre des Rêves

2019-01-23T12:20:37Z

Pschyt : /* Code utilisé pour le prototype */

[[Fichier:Logo-enib.png|300px]]

==INTRODUCTION==
Nous sommes trois élèves de l'ENIB, Anicia Velonkasina, Truel François et Picart Flavien, qui participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|100px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre des Rêves.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec
* une pile
* un adapteur pile à alimentation de la carte arduino

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

[[Fichier:Branchements_leds_finaux.jpg|300px]]

''branchements finaux des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

[[Fichier:Arbre eteint.jpg|400px]]

''arbre éteins''

==Le rendu==

Une fois que vous avez fait toutes les étapes, lancer l'arbre et voici le résultat:

[[Fichier:Arbre allume.jpg|400px]]

''arbre allumé''

==Code utilisé pour le prototype==

//============= Arbre Veilleuse ==============

//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,

//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.

//Définition des variables de broche
const int bp = 6;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 10
000; // intervalle de clignotement (millisecondes)
void setup() { //Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);}

void loop()
{ unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
while(StateBp==HIGH){
StateBp = digitalRead(bp);
delay(10); }
ExtinctionAll(StateLed);//reset}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval) {
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]); }
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval) {
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;}}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("BP = "); Serial.print(StateBp); Serial.print('\n');
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4]){
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;}
//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4]){
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;}
//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi){
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;}

[[catégorie:enib2019]]

L'arbre des Rêves

2019-01-23T12:20:08Z

Pschyt : /* Code utilisé pour le prototype */

[[Fichier:Logo-enib.png|300px]]

==INTRODUCTION==
Nous sommes trois élèves de l'ENIB, Anicia Velonkasina, Truel François et Picart Flavien, qui participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|100px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre des Rêves.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec
* une pile
* un adapteur pile à alimentation de la carte arduino

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

[[Fichier:Branchements_leds_finaux.jpg|300px]]

''branchements finaux des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

[[Fichier:Arbre eteint.jpg|400px]]

''arbre éteins''

==Le rendu==

Une fois que vous avez fait toutes les étapes, lancer l'arbre et voici le résultat:

[[Fichier:Arbre allume.jpg|400px]]

''arbre allumé''

==Code utilisé pour le prototype==

//============= Arbre Veilleuse ==============

//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,

//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.

//Définition des variables de broche
const int bp = 6;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 10
000; // intervalle de clignotement (millisecondes)
void setup() { //Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);}

void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
while(StateBp==HIGH){
StateBp = digitalRead(bp);
delay(10); }
ExtinctionAll(StateLed);//reset}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval) {
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]); }
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval) {
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;}}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("BP = "); Serial.print(StateBp); Serial.print('\n');
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4]){
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;}
//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4]){
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;}
//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi){
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;}

[[catégorie:enib2019]]

L'arbre des Rêves

2019-01-23T12:19:33Z

Pschyt : /* Code utilisé pour le prototype */

[[Fichier:Logo-enib.png|300px]]

==INTRODUCTION==
Nous sommes trois élèves de l'ENIB, Anicia Velonkasina, Truel François et Picart Flavien, qui participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|100px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre des Rêves.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec
* une pile
* un adapteur pile à alimentation de la carte arduino

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

[[Fichier:Branchements_leds_finaux.jpg|300px]]

''branchements finaux des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

[[Fichier:Arbre eteint.jpg|400px]]

''arbre éteins''

==Le rendu==

Une fois que vous avez fait toutes les étapes, lancer l'arbre et voici le résultat:

[[Fichier:Arbre allume.jpg|400px]]

''arbre allumé''

==Code utilisé pour le prototype==

//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 6;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 10
000; // intervalle de clignotement (millisecondes)
void setup() { //Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
while(StateBp==HIGH){
StateBp = digitalRead(bp);
delay(10); }
ExtinctionAll(StateLed);//reset}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval) {
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]); }
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval) {
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;}}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("BP = "); Serial.print(StateBp); Serial.print('\n');
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4]){
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;}
//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4]){
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;}
//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi){
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;}

[[catégorie:enib2019]]

L'arbre des Rêves

2019-01-21T14:21:22Z

Pschyt : /* Dernière étape */

[[Fichier:Logo-enib.png|300px]]

==INTRODUCTION==
Nous sommes trois élèves de l'ENIB, Anicia Velonkasina, Truel François et Picart Flavien, qui participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|100px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre des Rêves.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec
* une pile
* un adapteur pile à alimentation de la carte arduino

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

[[Fichier:Branchements_leds_finaux.jpg|300px]]

''branchements finaux des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

[[Fichier:Arbre eteint.jpg|400px]]

''arbre éteins''

==Le rendu==

Une fois que vous avez fait toutes les étapes, lancer l'arbre et voici le résultat:

[[Fichier:Arbre allume.jpg|400px]]

''arbre allumé''

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

[[catégorie:enib2019]]

Fichier:Arbre allume.jpg

2019-01-21T14:19:11Z

Pschyt : arbre final allumé

arbre final allumé

L'arbre des Rêves

2019-01-21T14:18:40Z

Pschyt :

[[Fichier:Logo-enib.png|300px]]

==INTRODUCTION==
Nous sommes trois élèves de l'ENIB, Anicia Velonkasina, Truel François et Picart Flavien, qui participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|100px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre des Rêves.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec
* une pile
* un adapteur pile à alimentation de la carte arduino

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

[[Fichier:Branchements_leds_finaux.jpg|300px]]

''branchements finaux des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

[[Fichier:Arbre eteint.jpg|400px]]

''arbre éteins''

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

[[catégorie:enib2019]]

L'arbre des Rêves

2019-01-21T14:17:53Z

Pschyt : /* Dernière étape */

[[Fichier:Logo-enib.png|300px]]

==INTRODUCTION==
Nous sommes trois élèves de l'ENIB, Anicia Velonkasina, Truel François et Picart Flavien, qui participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|100px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre des Rêves.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec
* une pile
* un adapteur pile à alimentation de la carte arduino

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

[[Fichier:Branchements_leds_finaux.jpg|300px]]

''branchements finaux des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

Arbre eteint.jpg

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

[[catégorie:enib2019]]

Fichier:Arbre eteint.jpg

2019-01-21T14:17:16Z

Pschyt : arbre fini éteint

arbre fini éteint

L'arbre des Rêves

2019-01-21T13:48:54Z

Pschyt : /* INTRODUCTION */

[[Fichier:Logo-enib.png|300px]]

==INTRODUCTION==
Nous sommes trois élèves de l'ENIB, Anicia Velonkasina, Truel François et Picart Flavien, qui participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|100px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre des Rêves.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec
* une pile
* un adapteur pile à alimentation de la carte arduino

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

[[Fichier:Branchements_leds_finaux.jpg|300px]]

''branchements finaux des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

[[catégorie:enib2019]]

L'arbre des Rêves

2019-01-21T13:39:19Z

Pschyt : /* Première étape */

[[Fichier:Logo-enib.png|300px]]

==INTRODUCTION==
Nous sommes trois élèves de l'ENIB, Anicia Velonkasina, Truel François et Picart Flavien, qui participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|100px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec
* une pile
* un adapteur pile à alimentation de la carte arduino

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

[[Fichier:Branchements_leds_finaux.jpg|300px]]

''branchements finaux des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

[[catégorie:enib2019]]

Fichier:Branchements leds finaux.jpg

2019-01-21T13:37:55Z

Pschyt : Branchement définitifs des leds

Branchement définitifs des leds

L'arbre des Rêves

2019-01-21T13:33:59Z

Pschyt :

[[Fichier:Logo-enib.png|300px]]

==INTRODUCTION==
Nous sommes trois élèves de l'ENIB, Anicia Velonkasina, Truel François et Picart Flavien, qui participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|100px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec
* une pile
* un adapteur pile à alimentation de la carte arduino

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

[[catégorie:enib2019]]

L'arbre des Rêves

2019-01-21T13:31:24Z

Pschyt : Pschyt a déplacé la page L'attrape rêve vers L'arbre des Rêves

[[Fichier:Logo-enib.png|300px]]

==INTRODUCTION==
Nous sommes trois élèves de l'ENIB, Anicia Velonkasina, Truel François et Picart Flavien, qui participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|100px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec
* une pile
* un adapteur pile à alimentation de la carte arduino

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'attrape rêve

2019-01-21T13:31:24Z

Pschyt : Pschyt a déplacé la page L'attrape rêve vers L'arbre des Rêves

#REDIRECTION [[L'arbre des Rêves]]

L'arbre des Rêves

2019-01-21T13:30:58Z

Pschyt :

[[Fichier:Logo-enib.png|300px]]

==INTRODUCTION==
Nous sommes trois élèves de l'ENIB, Anicia Velonkasina, Truel François et Picart Flavien, qui participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|100px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec
* une pile
* un adapteur pile à alimentation de la carte arduino

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T13:30:39Z

Pschyt :

=L'arbre des Rêves=

[[Fichier:Logo-enib.png|300px]]

==INTRODUCTION==
Nous sommes trois élèves de l'ENIB, Anicia Velonkasina, Truel François et Picart Flavien, qui participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|100px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec
* une pile
* un adapteur pile à alimentation de la carte arduino

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T13:27:52Z

Pschyt : /* INTRODUCTION */

[[Fichier:Logo-enib.png|300px]]

==INTRODUCTION==
Nous sommes trois élèves de l'ENIB, Anicia Velonkasina, Truel François et Picart Flavien, qui participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|100px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec
* une pile
* un adapteur pile à alimentation de la carte arduino

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T13:27:28Z

Pschyt : /* INTRODUCTION */

==INTRODUCTION==
Nous sommes trois élèves de l'ENIB, Anicia Velonkasina, Truel François et Picart Flavien, qui participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:Logo-enib.png|300px]]

[[Fichier:FlyerENIB2019.jpg|100px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec
* une pile
* un adapteur pile à alimentation de la carte arduino

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T13:26:54Z

Pschyt : /* INTRODUCTION */

==INTRODUCTION==
Nous sommes trois élèves de l'ENIB, Anicia Velonkasina, Truel François et Picart Flavien, qui participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|100px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec
* une pile
* un adapteur pile à alimentation de la carte arduino

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T13:26:00Z

Pschyt : /* Le matériel nécessaire */

==INTRODUCTION==
Nous sommes trois élèves de l'ENIB, Anicia Velonkasina, Truel François et Picart Flavien, qui participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec
* une pile
* un adapteur pile à alimentation de la carte arduino

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T13:24:39Z

Pschyt : /* INTRODUCTION */

==INTRODUCTION==
Nous sommes trois élèves de l'ENIB, Anicia Velonkasina, Truel François et Picart Flavien, qui participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T13:24:07Z

Pschyt : /* INTRODUCTION */

==INTRODUCTION==
Nous sommes trois élèves de l'ENIB, Anicia Velonkasina True François et Picart Flavien, qui participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T13:20:14Z

Pschyt : /* Première étape */

==INTRODUCTION==
Nous participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|300px]]

''boîte après le collage des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T13:19:12Z

Pschyt : /* INTRODUCTION */

==INTRODUCTION==
Nous participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|500px]]

''boîte après le collage des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T13:13:50Z

Pschyt :

==INTRODUCTION==
Nous participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

Une fois le câblage effectué, copier le code qui est en bas de cette page et transféré le dans la carte arduino, vérifier bien son fonctionnement.

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|500px]]

''boîte après le collage des leds''

Débranchez le bouton poussoir et le fixer sur le dessus de la boîte pour pouvoir changer de cycle quand on le décide.

====deuxième étape====

Fixez la carte arduino et la labdec sur la plaque qui referme la boîte, avant de refermer, vérifier qu'il est possible d'accéder à la carte arduino avec le câble pour changer de programme si on le souhait. Brancher la pile sur la carte grâce à l'adaptateur.
Refermer la boîte.

====Dernière étape====

Fixer l'arbre sur le dessus de la boîte.

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T13:05:27Z

Pschyt :

==INTRODUCTION==
Nous participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

[[Fichier:Boite led.jpg|500px]]

''boîte après le collage des leds''

====deuxième étape====

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T13:04:47Z

Pschyt : /* assemblage de l'ensemble */

==INTRODUCTION==
Nous participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

== assemblage de l'ensemble==

Pour cette dernière étape, nous avons besoin de tout ce que nous avons construit depuis le début.

====Première étape====

Débrancher les leds et mettez un câble mâle-femelle pour les relier à la plaque, avant de rebrancher les leds, coller les dans les trou préalablement fait.
Puis rebrancher les leds.

Boite led.jpg

''boîte après le collage des leds''

====deuxième étape====

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

Fichier:Boite led.jpg

2019-01-21T13:04:10Z

Pschyt : boîte une fois les leds collé

boîte une fois les leds collé

L'arbre des Rêves

2019-01-21T13:00:41Z

Pschyt : /* Dernière étape */

==INTRODUCTION==
Nous participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

== assemblage de l'ensemble==

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T13:00:03Z

Pschyt : /* création du circuit électrique */

==INTRODUCTION==
Nous participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]]

[[Fichier:Cablage led2.jpg|400px]]

''câblage test sur la plaque labdec''

== assemblage de l'ensemble==

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T12:59:29Z

Pschyt : /* création du circuit électrique */

==INTRODUCTION==
Nous participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|400px]] [[Fichier:Cablage led2.jpg|400px]]

== assemblage de l'ensemble==

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

Fichier:Cablage led2.jpg

2019-01-21T12:58:57Z

Pschyt : 2eme câblage test

2eme câblage test

L'arbre des Rêves

2019-01-21T12:57:36Z

Pschyt : /* création du circuit électrique */

==INTRODUCTION==
Nous participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, de la plaque labdec d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

Pour nos tests, nous avons câbler les leds sur la plaque labdec, ensuite nous modifierons le câblage des leds pour l'assemblage final.

Voici ce que nous obtenons une fois le câblage effectué:

[[Fichier:Cablage led1.jpg|600px]]

== assemblage de l'ensemble==

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

Fichier:Cablage led1.jpg

2019-01-21T12:57:05Z

Pschyt : Câblage test des leds

Câblage test des leds

L'arbre des Rêves

2019-01-21T12:53:09Z

Pschyt : /* création du circuit électrique */

==INTRODUCTION==
Nous participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Pour cette étape, nous avons besoin de leds, de câbles (mâle-mâle, mâle-femelle), de la carte arduino, d'un ordinateurs avec le logiciel arduino, d'un bouton poussoir, de résistances (valeurs plutôt faible, quelque 100Ω).

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

Une fois le schéma de principe fait, câblons le.

== assemblage de l'ensemble==

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T12:47:30Z

Pschyt : /* création de la boîte */

==INTRODUCTION==
Nous participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Pour cette étape, nous avons besoin l'arbre précédemment construit, de bois(ou de quoi faire une boîte), et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

== assemblage de l'ensemble==

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T12:46:30Z

Pschyt : /* création de la boîte */

==INTRODUCTION==
Nous participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Prenez l'arbre, du bois, et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

[[Fichier:Boite_Percage.jpg|400px]]

''boîte après le perçage''

== création du circuit électrique==

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

== assemblage de l'ensemble==

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

Fichier:Boite Percage.jpg

2019-01-21T12:45:43Z

Pschyt : Boîte une fois le perçage effectué

Boîte une fois le perçage effectué

L'arbre des Rêves

2019-01-21T10:37:57Z

Pschyt : /* création de la boîte */

==INTRODUCTION==
Nous participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Prenez l'arbre, du bois, et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

''boîte avant le perçage''

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

== création du circuit électrique==

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

== assemblage de l'ensemble==

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T10:33:46Z

Pschyt : /* création de la boîte */

==INTRODUCTION==
Nous participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Prenez l'arbre, du bois, et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur2.jpg|400px]]

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

== création du circuit électrique==

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

== assemblage de l'ensemble==

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

Fichier:Boite interieur2.jpg

2019-01-21T10:33:21Z

Pschyt : boîte de l'arbre rêve

boîte de l'arbre rêve

L'arbre des Rêves

2019-01-21T10:31:45Z

Pschyt : /* création de la boîte */

==INTRODUCTION==
Nous participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Prenez l'arbre, du bois, et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite interieur.jpg|400px]]

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

== création du circuit électrique==

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

== assemblage de l'ensemble==

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

Fichier:Boite interieur.jpg

2019-01-21T10:31:00Z

Pschyt : Pschyt a importé une nouvelle version de « Fichier:Boite interieur.jpg »

l'intérieur de notre boîte

L'arbre des Rêves

2019-01-21T10:29:16Z

Pschyt :

==INTRODUCTION==
Nous participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Prenez l'arbre, du bois, et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

[[Fichier:Boite_interieur.jpg|400px]]

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

== création du circuit électrique==

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

== assemblage de l'ensemble==

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T10:28:38Z

Pschyt : /* création de la boîte */

==INTRODUCTION==
Nous participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Prenez l'arbre, du bois, et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.
Boite_interieur.jpg

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

== création du circuit électrique==

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

== assemblage de l'ensemble==

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

Fichier:Boite interieur.jpg

2019-01-21T10:28:20Z

Pschyt : l'intérieur de notre boîte

l'intérieur de notre boîte

L'arbre des Rêves

2019-01-21T10:27:40Z

Pschyt :

==INTRODUCTION==
Nous participons au hackathon 2019 lors de notre inter semestre.

[[Fichier:FlyerENIB2019.jpg|200px]]

C'est dans ce contexte que nous avons eu l'idée de notre arbre attrape rêve.

Celui-ci sert à pour unique but d'être une veilleuse pour les enfants ou les personnes qui ne veulent pas dormir dans le noir.
Il a une forme, comme son nom l'indique, d'arbre et est lumineux grâce aux leds qui sont commandées par une carte arduino.

==Le matériel nécessaire==
* une carte arduino
* du fil électrique
* des leds
* une pince à dénuder
* de quoi faire une boîte
* un bouton poussoir
* une plaque labdec

== création de l'arbre==

[[Fichier:ArbreTest.jpg|250px]]

''Première ébauche de notre arbre''

Pour cette étape, nous avons besoins de fils et de temps (beaucoup de temps).

====première étape====

Prendre un fil assez épais et solide et faire un cercle du diamètre voulu.

====deuxième étape====

Prendre un autre câble, le découper en plein de bout de même longueur.
Une fois le découpage terminer, dénuder ou non les fils selon vos goût.

Puis enrouler tous les câbles sur un côté de l'arc de cercle, enrouler ensuite vos fils de manière a faire un tronc, puis séparé les au fur et à mesure pour faire des branches de moins en moins épaisses et enroulé de nouveaux les câbles sur l'arc de cercle.

====Dernière étape====

prendre un câble très long. Dénuder le ou non selon vos goût, puis torsader le autour du cercle.

Voici le résultat :

[[Fichier:Arbre final.jpg|400px]]

''Arbre final''

== création de la boîte==

Prenez l'arbre, du bois, et de quoi le fixer (clous, vis à bois ...)

Dimensionner la planche supérieur de votre boîte en fonction du diamètre de votre arbre, il doit être poser dessus sans problème.
Puis faite un entourage pour pouvoir mettre la carte arduino et le câblage dans votre boîte.
Une fois couper fixez les côtés de votre boîte.

Posez votre arbre sur le dessus de votre boîte et marqué les endroits où vous voulez mettre vos leds.
Puis percez les trous aux endroits marqué.

== création du circuit électrique==

Nous avons câblé notre arbre suivant ce modèle :

[[Fichier:SchémaArbreRêve.PNG|800px]]

''schéma de câblage de notre arbre''

== assemblage de l'ensemble==

==Code utilisé pour le prototype==
//============= Arbre Veilleuse ==============
//Coordonner 4 groupes de 5 leds pour réaliser différentes fonctions (clignoter ensemble/séparément,
//rester allumées/éteintes, clignotement alterné,etc) à partir d'un appui sur le bouton poussoir.
//Définition des variables de broche
const int bp = 1;
const int grpLed_1 = 2;
const int grpLed_2 = 3;
const int grpLed_3 = 4;
const int grpLed_4 = 5;
//Définition des variables d'état
int StateBp = digitalRead(bp);
bool StateLed[4]={LOW, LOW, LOW, LOW};
int mode = 0; //Mode par défaut
int etape =0; //Etape clignotement
unsigned long previousMillis = 0; // Dernier instant où l'état de la led a été modifié
const long interval = 500; // intervalle de clignotement (millisecondes)
void setup() {
//Initialisation de la communication série à 9600 bits par seconde
Serial.begin(9600);
//Indication des entrées
pinMode(bp, INPUT);
pinMode(grpLed_1, OUTPUT);
pinMode(grpLed_2, OUTPUT);
pinMode(grpLed_3, OUTPUT);
pinMode(grpLed_4, OUTPUT);
}
void loop() {
unsigned long currentMillis = millis();
//Rafraichissement des lectures du bouton poussoir
StateBp = digitalRead(bp);
//Un changement de mode ?
if (StateBp == HIGH)
{ Serial.print("Hey !! mode = ");Serial.println(mode);
mode+=1;
ExtinctionAll(StateLed);//reset
}
//Modifie les états des Leds selon le mode
switch (mode) {
case 1 : //Allumage de l'ensemble des led
AllumerAll(StateLed);
break;
case 2 : //Clignotement de toutes les leds simultanément
if (currentMillis - previousMillis >= interval)
{
StateLed[0]=ClignoterGrp(StateLed[0]);
StateLed[1]=ClignoterGrp(StateLed[1]);
StateLed[2]=ClignoterGrp(StateLed[2]);
StateLed[3]=ClignoterGrp(StateLed[3]);
}
break;
case 3 : //Alumage des leds les unes après les autres
if (currentMillis - previousMillis >= interval)
{
etape+=1; //Passage à l'étape suivante
switch (etape) { // Allumer un groupe ou plusieurs en fonction de la séquence définie
case 1 :
StateLed[3] = LOW;
StateLed[0] = HIGH;
break;
case 2 :
StateLed[0] = LOW;
StateLed[1] = HIGH;
break;
case 3 :
StateLed[1] = LOW;
StateLed[2] = HIGH;
break;
case 4 :
StateLed[2] = LOW;
StateLed[3] = HIGH;
etape=0;
break;
default :
etape=0;
break;
}
}
break;
default :
//Si le mode n'est pas l'un de ceux au dessus, on éteint les leds et on fait passer le mode à 0
mode = 0;
ExtinctionAll(StateLed);
break;
}
//Retour vers les sorties
digitalWrite(grpLed_1, StateLed[0]);
digitalWrite(grpLed_2, StateLed[1]);
digitalWrite(grpLed_3, StateLed[2]);
digitalWrite(grpLed_4, StateLed[3]);
//Affichage console pour vérification
Serial.print("Rouge = "); Serial.print(StateLed[0]); Serial.print('\n');
Serial.print("Bleu = "); Serial.print(StateLed[1]); Serial.print('\n');
Serial.print("Vert = "); Serial.print(StateLed[2]); Serial.print('\n');
Serial.print("Jaune = "); Serial.print(StateLed[3]); Serial.print('\n');
Serial.print('\n');
}//loop
//Fonction pour éteindre toutes les leds
void ExtinctionAll(bool StateLed[4])
{
StateLed[0] = LOW;
StateLed[1] = LOW;
StateLed[2] = LOW;
StateLed[3] = LOW;
}

//Fonction pour éteindre toutes les leds
void AllumerAll(bool StateLed[4])
{
StateLed[0] = HIGH;
StateLed[1] = HIGH;
StateLed[2] = HIGH;
StateLed[3] = HIGH;
}

//Fonction pour faire clignoter un des groupes de leds
bool ClignoterGrp(bool StateLedi)
{
if (StateLedi == HIGH)
{StateLedi=LOW;}
else
{StateLedi=HIGH;}
return StateLedi;
}

L'arbre des Rêves

2019-01-21T10:13:32Z

Pschyt :

L'arbre des Rêves

2019-01-21T10:12:53Z

Pschyt :

L'arbre des Rêves

2019-01-21T10:08:47Z

Pschyt :