Wiki de bureau d'études PeiP - Contributions de l’utilisateur [fr]

Binome2019-9

2020-05-21T19:01:01Z

Bblack : /* Clé USB */

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Introduction </div>=

Dans ce BE, l'objectif est de réaliser une clé usb avoir une ou plusieurs fonctionnalités originales. La première partie est donc de réflechir à différentes idées de fonctions à introduire sur cette clé.

----

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Partie Réflexion </div>=

Le principal objectif est de tenter d'imbriquer des clés par le biais d'un hub.

Nous avons aussi plusieurs idées de fonctionnalités originales de la clé USB :

*un haut-parleur (bruitage lors du remplissage, de la connexion, etc)
*vumètre à LED
*Dévérouillage de la clé via un mot de passe, on scinde la clé en 2 parties, la première ayant un stockage minimal servant à la demande du mot de passe, l'autre utile pour le stockage et l'échange d'informations. (bip d'erreur en cas d'échec du mot de passe)
*ajouter de la mémoire via un SHIELD

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Composants </div>=

*Le coeur qui va être un micro-contrôleur AVR plus exactement l'ATMega16u2.
*une mémoire faible capacité (64Mb) avec l'AT45DB641E-SHN2B-T ou une grande capacité mais plus difficile à souder (128Gb) avec l'MT29F128G8

TUSB4041I Four-Port USB 2.0 Hub

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Test ReX 15/03/2020 </div>=
Test ReX 15/03/2020
Après quelques soudures le programme suivant passe sur l'ATtiny84 :

#define MAX_LED 7
int leds[]={0,1,2,3,4,5,6};
void setup() {
int i;
for(i=0;i<MAX_LED;i++) pinMode(leds[i], OUTPUT);
}
void loop() {
int i;
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], HIGH);
delay(1000);
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], LOW);
delay(1000);
}

Démonstration de l'exécution : [[media:binome2019-9-test1.mp4]].

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Projet Intermédiaire: Le dé électronique </div>=

Ce projet nous a permis de prendre en main le logiciel Fritzing et Arduino IDE, ce qui nous sera utile par la suite pour la conception de la clé USB.

Tout d'abord nous avons élaboré les plans de notre dé en vue schématique, ce qui nous permet d'y voir plus clair et de mieux comprendre notre carte.
Après avoir effectué notre schématique (schéma1), celui-ci est indispensable car dès que l'on se retrouve avec beaucoup de composant, on s'y perd facilement, l'erreur est donc plus facilement détectable et il est conseiller d'utiliser des label pour facilité la compréhension.

Le schéma finit, il faut maintenant agencer les composants de sorte qu'aucunes pistes ne se croisent sur notre circuit imprimé (schéma 2).

Voici une photo de la vue schématique et du circuit imprimé

[[Fichier:schéma1_de.jpg|thumb|center|200px]]
[[Fichier:schéma 2 de.jpg|thumb|center|200px]]
[[Fichier:schéma 3 de.jpg|thumb|center|200px]]

Par la suite nos avons soudé sur notre circuit les 7 leds et 7 résistances, un travail minutieux et assez compliqué, surtout pour les premières soudures.

Il ne reste plus qu'a coder notre microcontroleur, pour ce faire on utilise l'Arduino IDE.
Le code ci-dessous va nous permettre d'afficher un nombre aléatoire entre 1 et 6.
Lorsque l'on va venir presser le bouton, un roulement de tambour va s'effectuer en affichant aléatoirement des chiffres à la suite et pour finir le nombre aléatoire choisi va se figer.

Voici le code:
//========FONCTIONS PERSONALISEES - Il s'agit de fonctions créées sur mesure pour nos besoins

void toutEteindre() { //Cette fonction permet d'éteindre toutes les leds. Elle est de type "void" car elle ne revoit aucune valeur: elle se content d'exécuter les instructions.
digitalWrite(0, LOW); //Eteindre la led 1
digitalWrite(1, LOW); //Eteindre la led 2
digitalWrite(2, LOW); //Eteindre la led 3
digitalWrite(3, LOW); //Eteindre la led 4
digitalWrite(4, LOW); //Eteindre la led 5
digitalWrite(5, LOW); //Eteindre la led 6
digitalWrite(6, LOW); //Eteindre la led 7
}

void afficher(int nb) { //Cette fonction permet d'allumer les bonnes leds en fonction du nombre choisi.
//Elle prend en paramètre le nombre que l'on veut afficher.
switch (nb) { //C'est pareil qu'un if sauf que le if prend que des valeurs booléennes
case 1:
digitalWrite(4, HIGH);
break;
case 2:
digitalWrite(1, HIGH);
digitalWrite(6, HIGH);
break;
case 3:
digitalWrite(0, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
break;
case 4:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
break;
case 5:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
digitalWrite(4, HIGH);
break;
case 6:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
break;
}
}

int chercher() {
return random(1, 7);
}

//=================================================

void setup() {
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9,INPUT_PULLUP);
}

void loop() {
if (digitalRead(9) == LOW) {

for (int i = 1; i <= random(8, 15); i++) { // On fait defiler plusieurs nombre pour le suspens
afficher(chercher());
delay(200);
toutEteindre();
}
afficher(chercher()); //On affiche le "vrai" chiffre.
delay(3000);
toutEteindre();

}
}

Le résultat final en vidéo et quelques photos de notre circuit imprimé final: [[Fichier: 20200328_165241.mp4|thumb|center|200px]]

[[Fichier:Photo1 de.jpg|thumb|center|200px]]
[[Fichier: photo2 de.jpg|thumb|center|200px]]

voici le Fritzing de notre dé: [[File:Circuit_de_1.zip]]

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Clé USB </div>=

Afin de concevoir notre clé usb nous sommes avons choisi comme base de travail cette clé usb: [[File:cle_usb_schema.png|thumb|left|400px|Schéma électronique]]

Pour l'amélioration de notre clé usb nous avons décider de faire un vu mètre avec des leds. Apres avoir discuté de cela avec nos professeurs ce qui nous a été conseillé est un registre à décalage.

Principe du registre à décalage :
Pour notre clé, on utilise un registre à décalage 75HC595 (8 bits). Il permet de convertir une information série en parallèle. Mais on l'utilise aussi pour économiser le nombre de broche utilisée en sortie.

Les différentes étapes sont : -1- On place la valeur sur la broche DS
-2- La broche SH_CP est mise à 1 (la valeur de la broche DS avance donc dans le registre)
-3- Remise à 0 de la broche SH_CP (on place la valeur du bit suivant sur la broche DS)
-4- La broche SH_CP est mise à nouveau à 1
-5- Les étapes 3 / 4 sont répétées autant de fois que nécessaire pour remplir le registre
-6- La broche ST_CP est mise à 1 (les valeurs présentent dans le registre sont copiées
sur les sortie Qn)

Comme on peut le voir, il y a 2 grandes phases : La première on place les données que l'on veut, la deuxième est la validation des données.

Voici notre registre à décalage: [[Fichier:Registre a decalage.png|thumb|center|200px]]

Il faut maintenant réussir à faire fonctionner tout ça via un code
Voici un début de code permettant de faire fonctionner ce registre à décalage, ici ce sont les instructions de base, nous n'avons cependant pas eu le temps faire en sorte que notre programme nous permette d'allumer et éteindre les leds en fonction du niveau de stockage.

void setup()
{
int DS_pin = 8; // broche de donnée
int STCP_pin = 9; // broche de validation de la donnée
int SHCP_pin = 10; // broche de validation compléte (latch)

boolean registre[8]; //c'est un tableau de 8 bit correspondant aux sorties du 74HC595 à l'état voulu

//configure les broches en sortie
pinMode(DS_pin,OUTPUT);
pinMode(STCP_pin,OUTPUT);
pinMode(SHCP_pin,OUTPUT);
}

//Cette fonction "écrit" le contenu du tableau dans le registre
//pour chaque bit, on met la brohe de validation du bit à 0, on place la broche de donnée à l'état contenu dans le tableau et ensuite on valide le bit
//à la fin on valide le tout
void EcrireRegistre()
{

digitalWrite(STCP_pin, LOW);

for (int i = 7; i>=0; i--)
{
digitalWrite(SHCP_pin, LOW);
digitalWrite(DS_pin, registre[i] );
digitalWrite(SHCP_pin, HIGH);
}

digitalWrite(STCP_pin, HIGH);
}

//Dans la boucle du programme plusieurs séquences différentes sont jouées
void loop()
{
//Allume successivement les sorties
for(int i = 0; i<8; i++)
{
registre[i] = HIGH;
delay(300);
EcrireRegistre();
}

//éteint successivement les sorties
for(int i = 7; i>=0; i--)
{
registre[i] = LOW;
delay(300);
EcrireRegistre();

}

//séquence qui allume une LED sur 2 alternativement
bool b = 0;
for(int i = 0; i<4; i++)
{

for(int j = 0; j<8; j++)
{
registre[j] = j%2 xor b;
}
EcrireRegistre();
b = not b;
delay(300);
}

//remise à zéro de toutes les LED
for(int j = 0; j<8; j++)
{
registre[j] = 0;
}
EcrireRegistre();
}

Fichier Fritzing: [[Fichier:Cle usb black roussel.zip]]

Binome2019-9

2020-05-21T19:00:40Z

Bblack : /* Clé USB */

Fichier:Cle usb black roussel.zip

2020-05-21T15:18:04Z

Bblack : Bblack a téléversé une nouvelle version de Fichier:Cle usb black roussel.zip

Fichier:Cle usb black roussel.zip

2020-04-30T16:25:38Z

Bblack : Bblack a téléversé une nouvelle version de Fichier:Cle usb black roussel.zip

Fichier:Cle usb black roussel.zip

2020-04-30T16:15:32Z

Bblack : Bblack a téléversé une nouvelle version de Fichier:Cle usb black roussel.zip

Fichier:Cle usb black roussel.zip

2020-04-09T15:36:23Z

Bblack : Bblack a téléversé une nouvelle version de Fichier:Cle usb black roussel.zip

Binome2019-9

2020-04-09T15:27:50Z

Bblack : /* Clé USB */

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Introduction </div>=

Dans ce BE, l'objectif est de réaliser une clé usb avoir une ou plusieurs fonctionnalités originales. La première partie est donc de réflechir à différentes idées de fonctions à introduire sur cette clé.

----

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Partie Réflexion </div>=

Le principal objectif est de tenter d'imbriquer des clés par le biais d'un hub.

Nous avons aussi plusieurs idées de fonctionnalités originales de la clé USB :

*un haut-parleur (bruitage lors du remplissage, de la connexion, etc)
*vumètre à LED
*Dévérouillage de la clé via un mot de passe, on scinde la clé en 2 parties, la première ayant un stockage minimal servant à la demande du mot de passe, l'autre utile pour le stockage et l'échange d'informations. (bip d'erreur en cas d'échec du mot de passe)
*ajouter de la mémoire via un SHIELD

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Composants </div>=

*Le coeur qui va être un micro-contrôleur AVR plus exactement l'ATMega16u2.
*une mémoire faible capacité (64Mb) avec l'AT45DB641E-SHN2B-T ou une grande capacité mais plus difficile à souder (128Gb) avec l'MT29F128G8

TUSB4041I Four-Port USB 2.0 Hub

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Test ReX 15/03/2020 </div>=
Test ReX 15/03/2020
Après quelques soudures le programme suivant passe sur l'ATtiny84 :

#define MAX_LED 7
int leds[]={0,1,2,3,4,5,6};
void setup() {
int i;
for(i=0;i<MAX_LED;i++) pinMode(leds[i], OUTPUT);
}
void loop() {
int i;
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], HIGH);
delay(1000);
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], LOW);
delay(1000);
}

Démonstration de l'exécution : [[media:binome2019-9-test1.mp4]].

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Projet Intermédiaire: Le dé électronique </div>=

Ce projet nous a permis de prendre en main le logiciel Fritzing et Arduino IDE, ce qui nous sera utile par la suite pour la conception de la clé USB.

Tout d'abord nous avons élaboré les plans de notre dé en vue schématique, ce qui nous permet d'y voir plus clair et de mieux comprendre notre carte.
Après avoir effectué notre schématique (schéma1), celui-ci est indispensable car des que l'on se retrouve avec beaucoup de composant, on s'y perd facilement, l'erreur est donc plus facilement detectable et il est conseiller d'utiliser des label pour facilité la comprehension.

Le schéma finit, il faut maintenant agencer les composants de sorte qu'aucunes pistes ne se croisent sur notre circuit imprimé (schéma 2).

Voici une photo de la vue schématique et du circuit imprimé

[[Fichier:schéma1_de.jpg|thumb|center|200px]]
[[Fichier:schéma 2 de.jpg|thumb|center|200px]]
[[Fichier:schéma 3 de.jpg|thumb|center|200px]]

Par la suite nos avons soudé sur notre circuit les 7 leds et 7 résistances, un travail très minutieux et assez compliqué.

Il ne reste plus qu'a coder notre microcontroleur, pour ce faire on utilise l'Arduino IDE.
Le code ci-dessous va nous permettre d'afficher un nombre aléatoire entre 1 et 6.
Lorsque l'on va venir presser le bouton, un roulement de tambour va s'effectuer en affichant plein de chiffres à la suite aléatoirement puis ensuite le nombre aléatoire choisi va se figer.

Voici le code:
//========FONCTIONS PERSONALISEES - Il s'agit de fonctions créées sur mesure pour nos besoins

void toutEteindre() { //Cette fonction permet d'éteindre toutes les leds. Elle est de type "void" car elle ne revoit aucune valeur: elle se content d'exécuter les instructions.
digitalWrite(0, LOW); //Eteindre la led 1
digitalWrite(1, LOW); //Eteindre la led 2
digitalWrite(2, LOW); //Eteindre la led 3
digitalWrite(3, LOW); //Eteindre la led 4
digitalWrite(4, LOW); //Eteindre la led 5
digitalWrite(5, LOW); //Eteindre la led 6
digitalWrite(6, LOW); //Eteindre la led 7
}

void afficher(int nb) { //Cette fonction permet d'allumer les bonnes leds en fonction du nombre choisi.
//Elle prend en paramètre le nombre que l'on veut afficher.
switch (nb) { //C'est pareil qu'un if sauf que le if prend que des valeurs booléennes
case 1:
digitalWrite(4, HIGH);
break;
case 2:
digitalWrite(1, HIGH);
digitalWrite(6, HIGH);
break;
case 3:
digitalWrite(0, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
break;
case 4:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
break;
case 5:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
digitalWrite(4, HIGH);
break;
case 6:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
break;
}
}

int chercher() {
return random(1, 7);
}

//=================================================

void setup() {
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9,INPUT_PULLUP);
}

void loop() {
if (digitalRead(9) == LOW) {

for (int i = 1; i <= random(8, 15); i++) { // On fait defiler plusieurs nombre pour le suspens
afficher(chercher());
delay(200);
toutEteindre();
}
afficher(chercher()); //On affiche le "vrai" chiffre.
delay(3000);
toutEteindre();

}
}

Le résultat final en vidéo et quelques photos de notre circuit imprimé final: [[Fichier: 20200328_165241.mp4|thumb|center|200px]]

[[Fichier:Photo1 de.jpg|thumb|center|200px]]
[[Fichier: photo2 de.jpg|thumb|center|200px]]

voici le Fritzing de notre dé: [[File:Circuit_de_1.zip]]

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Clé USB </div>=

Afin de concevoir notre clé usb nous sommes avons choisi comme base de travail cette clé usb: [[File:cle_usb_schema.png|thumb|left|400px|Schéma électronique]]

Pour l'amélioration de notre clé usb nous avons décider de faire un vu mètre avec des leds. Apres avoir discuté de cela avec nos professeurs ce qui nous a été conseillé est un registre à décalage.

--description du fonctionnement à faire--

Voici notre registre à décalage: [[Fichier:Registre a decalage.png|thumb|center|200px]]

Fichier Fritzing ( je n'arrive pas à importer les composants de la parties mémoire ): [[Fichier:Cle usb black roussel.zip]]

Binome2019-9

2020-04-09T15:26:41Z

Bblack : /* Clé USB */

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Introduction </div>=

Dans ce BE, l'objectif est de réaliser une clé usb avoir une ou plusieurs fonctionnalités originales. La première partie est donc de réflechir à différentes idées de fonctions à introduire sur cette clé.

----

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Partie Réflexion </div>=

Le principal objectif est de tenter d'imbriquer des clés par le biais d'un hub.

Nous avons aussi plusieurs idées de fonctionnalités originales de la clé USB :

*un haut-parleur (bruitage lors du remplissage, de la connexion, etc)
*vumètre à LED
*Dévérouillage de la clé via un mot de passe, on scinde la clé en 2 parties, la première ayant un stockage minimal servant à la demande du mot de passe, l'autre utile pour le stockage et l'échange d'informations. (bip d'erreur en cas d'échec du mot de passe)
*ajouter de la mémoire via un SHIELD

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Composants </div>=

*Le coeur qui va être un micro-contrôleur AVR plus exactement l'ATMega16u2.
*une mémoire faible capacité (64Mb) avec l'AT45DB641E-SHN2B-T ou une grande capacité mais plus difficile à souder (128Gb) avec l'MT29F128G8

TUSB4041I Four-Port USB 2.0 Hub

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Test ReX 15/03/2020 </div>=
Test ReX 15/03/2020
Après quelques soudures le programme suivant passe sur l'ATtiny84 :

#define MAX_LED 7
int leds[]={0,1,2,3,4,5,6};
void setup() {
int i;
for(i=0;i<MAX_LED;i++) pinMode(leds[i], OUTPUT);
}
void loop() {
int i;
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], HIGH);
delay(1000);
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], LOW);
delay(1000);
}

Démonstration de l'exécution : [[media:binome2019-9-test1.mp4]].

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Projet Intermédiaire: Le dé électronique </div>=

Ce projet nous a permis de prendre en main le logiciel Fritzing et Arduino IDE, ce qui nous sera utile par la suite pour la conception de la clé USB.

Tout d'abord nous avons élaboré les plans de notre dé en vue schématique, ce qui nous permet d'y voir plus clair et de mieux comprendre notre carte.
Après avoir effectué notre schématique (schéma1), celui-ci est indispensable car des que l'on se retrouve avec beaucoup de composant, on s'y perd facilement, l'erreur est donc plus facilement detectable et il est conseiller d'utiliser des label pour facilité la comprehension.

Le schéma finit, il faut maintenant agencer les composants de sorte qu'aucunes pistes ne se croisent sur notre circuit imprimé (schéma 2).

Voici une photo de la vue schématique et du circuit imprimé

[[Fichier:schéma1_de.jpg|thumb|center|200px]]
[[Fichier:schéma 2 de.jpg|thumb|center|200px]]
[[Fichier:schéma 3 de.jpg|thumb|center|200px]]

Par la suite nos avons soudé sur notre circuit les 7 leds et 7 résistances, un travail très minutieux et assez compliqué.

Il ne reste plus qu'a coder notre microcontroleur, pour ce faire on utilise l'Arduino IDE.
Le code ci-dessous va nous permettre d'afficher un nombre aléatoire entre 1 et 6.
Lorsque l'on va venir presser le bouton, un roulement de tambour va s'effectuer en affichant plein de chiffres à la suite aléatoirement puis ensuite le nombre aléatoire choisi va se figer.

Voici le code:
//========FONCTIONS PERSONALISEES - Il s'agit de fonctions créées sur mesure pour nos besoins

void toutEteindre() { //Cette fonction permet d'éteindre toutes les leds. Elle est de type "void" car elle ne revoit aucune valeur: elle se content d'exécuter les instructions.
digitalWrite(0, LOW); //Eteindre la led 1
digitalWrite(1, LOW); //Eteindre la led 2
digitalWrite(2, LOW); //Eteindre la led 3
digitalWrite(3, LOW); //Eteindre la led 4
digitalWrite(4, LOW); //Eteindre la led 5
digitalWrite(5, LOW); //Eteindre la led 6
digitalWrite(6, LOW); //Eteindre la led 7
}

void afficher(int nb) { //Cette fonction permet d'allumer les bonnes leds en fonction du nombre choisi.
//Elle prend en paramètre le nombre que l'on veut afficher.
switch (nb) { //C'est pareil qu'un if sauf que le if prend que des valeurs booléennes
case 1:
digitalWrite(4, HIGH);
break;
case 2:
digitalWrite(1, HIGH);
digitalWrite(6, HIGH);
break;
case 3:
digitalWrite(0, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
break;
case 4:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
break;
case 5:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
digitalWrite(4, HIGH);
break;
case 6:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
break;
}
}

int chercher() {
return random(1, 7);
}

//=================================================

void setup() {
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9,INPUT_PULLUP);
}

void loop() {
if (digitalRead(9) == LOW) {

for (int i = 1; i <= random(8, 15); i++) { // On fait defiler plusieurs nombre pour le suspens
afficher(chercher());
delay(200);
toutEteindre();
}
afficher(chercher()); //On affiche le "vrai" chiffre.
delay(3000);
toutEteindre();

}
}

Le résultat final en vidéo et quelques photos de notre circuit imprimé final: [[Fichier: 20200328_165241.mp4|thumb|center|200px]]

[[Fichier:Photo1 de.jpg|thumb|center|200px]]
[[Fichier: photo2 de.jpg|thumb|center|200px]]

voici le Fritzing de notre dé: [[File:Circuit_de_1.zip]]

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Clé USB </div>=

Afin de concevoir notre clé usb nous sommes avons choisi comme base de travail cette clé usb: [[File:cle_usb_schema.png|thumb|left|400px|Schéma électronique]]

Pour l'amélioration de notre clé usb nous avons décider de faire un vu mètre avec des leds. Apres avoir discuté de cela avec nos professeurs ce qui nous a été conseillé est un registre à décalage.

--description du fonctionnement à faire--

Voici notre registre à décalage: [[Fichier:Registre a decalage.png|thumb|center|200px]]

Fichier Fritzing: [[Fichier:Cle usb black roussel.zip]]

Fichier:Cle usb black roussel.zip

2020-04-09T15:25:48Z

Bblack :

Binome2019-9

2020-04-09T15:25:31Z

Bblack : /* Clé USB */

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Introduction </div>=

Dans ce BE, l'objectif est de réaliser une clé usb avoir une ou plusieurs fonctionnalités originales. La première partie est donc de réflechir à différentes idées de fonctions à introduire sur cette clé.

----

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Partie Réflexion </div>=

Le principal objectif est de tenter d'imbriquer des clés par le biais d'un hub.

Nous avons aussi plusieurs idées de fonctionnalités originales de la clé USB :

*un haut-parleur (bruitage lors du remplissage, de la connexion, etc)
*vumètre à LED
*Dévérouillage de la clé via un mot de passe, on scinde la clé en 2 parties, la première ayant un stockage minimal servant à la demande du mot de passe, l'autre utile pour le stockage et l'échange d'informations. (bip d'erreur en cas d'échec du mot de passe)
*ajouter de la mémoire via un SHIELD

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Composants </div>=

*Le coeur qui va être un micro-contrôleur AVR plus exactement l'ATMega16u2.
*une mémoire faible capacité (64Mb) avec l'AT45DB641E-SHN2B-T ou une grande capacité mais plus difficile à souder (128Gb) avec l'MT29F128G8

TUSB4041I Four-Port USB 2.0 Hub

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Test ReX 15/03/2020 </div>=
Test ReX 15/03/2020
Après quelques soudures le programme suivant passe sur l'ATtiny84 :

#define MAX_LED 7
int leds[]={0,1,2,3,4,5,6};
void setup() {
int i;
for(i=0;i<MAX_LED;i++) pinMode(leds[i], OUTPUT);
}
void loop() {
int i;
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], HIGH);
delay(1000);
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], LOW);
delay(1000);
}

Démonstration de l'exécution : [[media:binome2019-9-test1.mp4]].

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Projet Intermédiaire: Le dé électronique </div>=

Ce projet nous a permis de prendre en main le logiciel Fritzing et Arduino IDE, ce qui nous sera utile par la suite pour la conception de la clé USB.

Tout d'abord nous avons élaboré les plans de notre dé en vue schématique, ce qui nous permet d'y voir plus clair et de mieux comprendre notre carte.
Après avoir effectué notre schématique (schéma1), celui-ci est indispensable car des que l'on se retrouve avec beaucoup de composant, on s'y perd facilement, l'erreur est donc plus facilement detectable et il est conseiller d'utiliser des label pour facilité la comprehension.

Le schéma finit, il faut maintenant agencer les composants de sorte qu'aucunes pistes ne se croisent sur notre circuit imprimé (schéma 2).

Voici une photo de la vue schématique et du circuit imprimé

[[Fichier:schéma1_de.jpg|thumb|center|200px]]
[[Fichier:schéma 2 de.jpg|thumb|center|200px]]
[[Fichier:schéma 3 de.jpg|thumb|center|200px]]

Par la suite nos avons soudé sur notre circuit les 7 leds et 7 résistances, un travail très minutieux et assez compliqué.

Il ne reste plus qu'a coder notre microcontroleur, pour ce faire on utilise l'Arduino IDE.
Le code ci-dessous va nous permettre d'afficher un nombre aléatoire entre 1 et 6.
Lorsque l'on va venir presser le bouton, un roulement de tambour va s'effectuer en affichant plein de chiffres à la suite aléatoirement puis ensuite le nombre aléatoire choisi va se figer.

Voici le code:
//========FONCTIONS PERSONALISEES - Il s'agit de fonctions créées sur mesure pour nos besoins

void toutEteindre() { //Cette fonction permet d'éteindre toutes les leds. Elle est de type "void" car elle ne revoit aucune valeur: elle se content d'exécuter les instructions.
digitalWrite(0, LOW); //Eteindre la led 1
digitalWrite(1, LOW); //Eteindre la led 2
digitalWrite(2, LOW); //Eteindre la led 3
digitalWrite(3, LOW); //Eteindre la led 4
digitalWrite(4, LOW); //Eteindre la led 5
digitalWrite(5, LOW); //Eteindre la led 6
digitalWrite(6, LOW); //Eteindre la led 7
}

void afficher(int nb) { //Cette fonction permet d'allumer les bonnes leds en fonction du nombre choisi.
//Elle prend en paramètre le nombre que l'on veut afficher.
switch (nb) { //C'est pareil qu'un if sauf que le if prend que des valeurs booléennes
case 1:
digitalWrite(4, HIGH);
break;
case 2:
digitalWrite(1, HIGH);
digitalWrite(6, HIGH);
break;
case 3:
digitalWrite(0, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
break;
case 4:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
break;
case 5:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
digitalWrite(4, HIGH);
break;
case 6:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
break;
}
}

int chercher() {
return random(1, 7);
}

//=================================================

void setup() {
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9,INPUT_PULLUP);
}

void loop() {
if (digitalRead(9) == LOW) {

for (int i = 1; i <= random(8, 15); i++) { // On fait defiler plusieurs nombre pour le suspens
afficher(chercher());
delay(200);
toutEteindre();
}
afficher(chercher()); //On affiche le "vrai" chiffre.
delay(3000);
toutEteindre();

}
}

Le résultat final en vidéo et quelques photos de notre circuit imprimé final: [[Fichier: 20200328_165241.mp4|thumb|center|200px]]

[[Fichier:Photo1 de.jpg|thumb|center|200px]]
[[Fichier: photo2 de.jpg|thumb|center|200px]]

voici le Fritzing de notre dé: [[File:Circuit_de_1.zip]]

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Clé USB </div>=

Afin de concevoir notre clé usb nous sommes avons choisi comme base de travail cette clé usb: [[File:cle_usb_schema.png|thumb|left|400px|Schéma électronique]]

Pour l'amélioration de notre clé usb nous avons décider de faire un vu mètre avec des leds. Apres avoir discuté de cela avec nos professeurs ce qui nous a été conseillé est un registre à décalage.

--description du fonctionnement à faire--

Voici notre registre à décalage: [[Fichier:Registre a decalage.png|thumb|center|200px]]

Fichier Fritzing: [[File:Cle_usb_black_roussel.zip]]

Binome2019-9

2020-04-09T15:24:46Z

Bblack : /* Clé USB */

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Introduction </div>=

Dans ce BE, l'objectif est de réaliser une clé usb avoir une ou plusieurs fonctionnalités originales. La première partie est donc de réflechir à différentes idées de fonctions à introduire sur cette clé.

----

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Partie Réflexion </div>=

Le principal objectif est de tenter d'imbriquer des clés par le biais d'un hub.

Nous avons aussi plusieurs idées de fonctionnalités originales de la clé USB :

*un haut-parleur (bruitage lors du remplissage, de la connexion, etc)
*vumètre à LED
*Dévérouillage de la clé via un mot de passe, on scinde la clé en 2 parties, la première ayant un stockage minimal servant à la demande du mot de passe, l'autre utile pour le stockage et l'échange d'informations. (bip d'erreur en cas d'échec du mot de passe)
*ajouter de la mémoire via un SHIELD

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Composants </div>=

*Le coeur qui va être un micro-contrôleur AVR plus exactement l'ATMega16u2.
*une mémoire faible capacité (64Mb) avec l'AT45DB641E-SHN2B-T ou une grande capacité mais plus difficile à souder (128Gb) avec l'MT29F128G8

TUSB4041I Four-Port USB 2.0 Hub

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Test ReX 15/03/2020 </div>=
Test ReX 15/03/2020
Après quelques soudures le programme suivant passe sur l'ATtiny84 :

#define MAX_LED 7
int leds[]={0,1,2,3,4,5,6};
void setup() {
int i;
for(i=0;i<MAX_LED;i++) pinMode(leds[i], OUTPUT);
}
void loop() {
int i;
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], HIGH);
delay(1000);
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], LOW);
delay(1000);
}

Démonstration de l'exécution : [[media:binome2019-9-test1.mp4]].

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Projet Intermédiaire: Le dé électronique </div>=

Ce projet nous a permis de prendre en main le logiciel Fritzing et Arduino IDE, ce qui nous sera utile par la suite pour la conception de la clé USB.

Tout d'abord nous avons élaboré les plans de notre dé en vue schématique, ce qui nous permet d'y voir plus clair et de mieux comprendre notre carte.
Après avoir effectué notre schématique (schéma1), celui-ci est indispensable car des que l'on se retrouve avec beaucoup de composant, on s'y perd facilement, l'erreur est donc plus facilement detectable et il est conseiller d'utiliser des label pour facilité la comprehension.

Le schéma finit, il faut maintenant agencer les composants de sorte qu'aucunes pistes ne se croisent sur notre circuit imprimé (schéma 2).

Voici une photo de la vue schématique et du circuit imprimé

[[Fichier:schéma1_de.jpg|thumb|center|200px]]
[[Fichier:schéma 2 de.jpg|thumb|center|200px]]
[[Fichier:schéma 3 de.jpg|thumb|center|200px]]

Par la suite nos avons soudé sur notre circuit les 7 leds et 7 résistances, un travail très minutieux et assez compliqué.

Il ne reste plus qu'a coder notre microcontroleur, pour ce faire on utilise l'Arduino IDE.
Le code ci-dessous va nous permettre d'afficher un nombre aléatoire entre 1 et 6.
Lorsque l'on va venir presser le bouton, un roulement de tambour va s'effectuer en affichant plein de chiffres à la suite aléatoirement puis ensuite le nombre aléatoire choisi va se figer.

Voici le code:
//========FONCTIONS PERSONALISEES - Il s'agit de fonctions créées sur mesure pour nos besoins

void toutEteindre() { //Cette fonction permet d'éteindre toutes les leds. Elle est de type "void" car elle ne revoit aucune valeur: elle se content d'exécuter les instructions.
digitalWrite(0, LOW); //Eteindre la led 1
digitalWrite(1, LOW); //Eteindre la led 2
digitalWrite(2, LOW); //Eteindre la led 3
digitalWrite(3, LOW); //Eteindre la led 4
digitalWrite(4, LOW); //Eteindre la led 5
digitalWrite(5, LOW); //Eteindre la led 6
digitalWrite(6, LOW); //Eteindre la led 7
}

void afficher(int nb) { //Cette fonction permet d'allumer les bonnes leds en fonction du nombre choisi.
//Elle prend en paramètre le nombre que l'on veut afficher.
switch (nb) { //C'est pareil qu'un if sauf que le if prend que des valeurs booléennes
case 1:
digitalWrite(4, HIGH);
break;
case 2:
digitalWrite(1, HIGH);
digitalWrite(6, HIGH);
break;
case 3:
digitalWrite(0, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
break;
case 4:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
break;
case 5:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
digitalWrite(4, HIGH);
break;
case 6:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
break;
}
}

int chercher() {
return random(1, 7);
}

//=================================================

void setup() {
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9,INPUT_PULLUP);
}

void loop() {
if (digitalRead(9) == LOW) {

for (int i = 1; i <= random(8, 15); i++) { // On fait defiler plusieurs nombre pour le suspens
afficher(chercher());
delay(200);
toutEteindre();
}
afficher(chercher()); //On affiche le "vrai" chiffre.
delay(3000);
toutEteindre();

}
}

Le résultat final en vidéo et quelques photos de notre circuit imprimé final: [[Fichier: 20200328_165241.mp4|thumb|center|200px]]

[[Fichier:Photo1 de.jpg|thumb|center|200px]]
[[Fichier: photo2 de.jpg|thumb|center|200px]]

voici le Fritzing de notre dé: [[File:Circuit_de_1.zip]]

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Clé USB </div>=

Afin de concevoir notre clé usb nous sommes avons choisi comme base de travail cette clé usb: [[File:cle_usb_schema.png|thumb|left|400px|Schéma électronique]]

Pour l'amélioration de notre clé usb nous avons décider de faire un vu mètre avec des leds. Apres avoir discuté de cela avec nos professeurs ce qui nous a été conseillé est un registre à décalage.

--description du fonctionnement à faire--

Voici notre registre à décalage: [[Fichier:Registre a decalage.png|thumb|center|200px]]

Fichier Fritzing:

Binome2019-9

2020-04-09T15:21:04Z

Bblack : /* Projet Intermédiaire: Le dé électronique */

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Introduction </div>=

Dans ce BE, l'objectif est de réaliser une clé usb avoir une ou plusieurs fonctionnalités originales. La première partie est donc de réflechir à différentes idées de fonctions à introduire sur cette clé.

----

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Partie Réflexion </div>=

Le principal objectif est de tenter d'imbriquer des clés par le biais d'un hub.

Nous avons aussi plusieurs idées de fonctionnalités originales de la clé USB :

*un haut-parleur (bruitage lors du remplissage, de la connexion, etc)
*vumètre à LED
*Dévérouillage de la clé via un mot de passe, on scinde la clé en 2 parties, la première ayant un stockage minimal servant à la demande du mot de passe, l'autre utile pour le stockage et l'échange d'informations. (bip d'erreur en cas d'échec du mot de passe)
*ajouter de la mémoire via un SHIELD

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Composants </div>=

*Le coeur qui va être un micro-contrôleur AVR plus exactement l'ATMega16u2.
*une mémoire faible capacité (64Mb) avec l'AT45DB641E-SHN2B-T ou une grande capacité mais plus difficile à souder (128Gb) avec l'MT29F128G8

TUSB4041I Four-Port USB 2.0 Hub

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Test ReX 15/03/2020 </div>=
Test ReX 15/03/2020
Après quelques soudures le programme suivant passe sur l'ATtiny84 :

#define MAX_LED 7
int leds[]={0,1,2,3,4,5,6};
void setup() {
int i;
for(i=0;i<MAX_LED;i++) pinMode(leds[i], OUTPUT);
}
void loop() {
int i;
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], HIGH);
delay(1000);
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], LOW);
delay(1000);
}

Démonstration de l'exécution : [[media:binome2019-9-test1.mp4]].

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Projet Intermédiaire: Le dé électronique </div>=

Ce projet nous a permis de prendre en main le logiciel Fritzing et Arduino IDE, ce qui nous sera utile par la suite pour la conception de la clé USB.

Tout d'abord nous avons élaboré les plans de notre dé en vue schématique, ce qui nous permet d'y voir plus clair et de mieux comprendre notre carte.
Après avoir effectué notre schématique (schéma1), celui-ci est indispensable car des que l'on se retrouve avec beaucoup de composant, on s'y perd facilement, l'erreur est donc plus facilement detectable et il est conseiller d'utiliser des label pour facilité la comprehension.

Le schéma finit, il faut maintenant agencer les composants de sorte qu'aucunes pistes ne se croisent sur notre circuit imprimé (schéma 2).

Voici une photo de la vue schématique et du circuit imprimé

[[Fichier:schéma1_de.jpg|thumb|center|200px]]
[[Fichier:schéma 2 de.jpg|thumb|center|200px]]
[[Fichier:schéma 3 de.jpg|thumb|center|200px]]

Par la suite nos avons soudé sur notre circuit les 7 leds et 7 résistances, un travail très minutieux et assez compliqué.

Il ne reste plus qu'a coder notre microcontroleur, pour ce faire on utilise l'Arduino IDE.
Le code ci-dessous va nous permettre d'afficher un nombre aléatoire entre 1 et 6.
Lorsque l'on va venir presser le bouton, un roulement de tambour va s'effectuer en affichant plein de chiffres à la suite aléatoirement puis ensuite le nombre aléatoire choisi va se figer.

Voici le code:
//========FONCTIONS PERSONALISEES - Il s'agit de fonctions créées sur mesure pour nos besoins

void toutEteindre() { //Cette fonction permet d'éteindre toutes les leds. Elle est de type "void" car elle ne revoit aucune valeur: elle se content d'exécuter les instructions.
digitalWrite(0, LOW); //Eteindre la led 1
digitalWrite(1, LOW); //Eteindre la led 2
digitalWrite(2, LOW); //Eteindre la led 3
digitalWrite(3, LOW); //Eteindre la led 4
digitalWrite(4, LOW); //Eteindre la led 5
digitalWrite(5, LOW); //Eteindre la led 6
digitalWrite(6, LOW); //Eteindre la led 7
}

void afficher(int nb) { //Cette fonction permet d'allumer les bonnes leds en fonction du nombre choisi.
//Elle prend en paramètre le nombre que l'on veut afficher.
switch (nb) { //C'est pareil qu'un if sauf que le if prend que des valeurs booléennes
case 1:
digitalWrite(4, HIGH);
break;
case 2:
digitalWrite(1, HIGH);
digitalWrite(6, HIGH);
break;
case 3:
digitalWrite(0, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
break;
case 4:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
break;
case 5:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
digitalWrite(4, HIGH);
break;
case 6:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
break;
}
}

int chercher() {
return random(1, 7);
}

//=================================================

void setup() {
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9,INPUT_PULLUP);
}

void loop() {
if (digitalRead(9) == LOW) {

for (int i = 1; i <= random(8, 15); i++) { // On fait defiler plusieurs nombre pour le suspens
afficher(chercher());
delay(200);
toutEteindre();
}
afficher(chercher()); //On affiche le "vrai" chiffre.
delay(3000);
toutEteindre();

}
}

Le résultat final en vidéo et quelques photos de notre circuit imprimé final: [[Fichier: 20200328_165241.mp4|thumb|center|200px]]

[[Fichier:Photo1 de.jpg|thumb|center|200px]]
[[Fichier: photo2 de.jpg|thumb|center|200px]]

voici le Fritzing de notre dé: [[File:Circuit_de_1.zip]]

=<div class="mcwiki-header" style="border-radius: 25px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #2E64FE; vertical-align: top; width: 98%;"> Clé USB </div>=

Afin de concevoir notre clé usb nous sommes avons choisi comme base de travail cette clé usb: [[File:cle_usb_schema.png|thumb|left|400px|Schéma électronique]]

Pour l'amélioration de notre clé usb nous avons décider de faire un vu mètre avec des leds. Apres avoir discuté de cela avec nos professeurs ce qui nous a été conseillé est un registre à décalage.

--description du fonctionnement à faire--

Voici notre registre à décalage: [[Fichier:Registre a decalage.png|thumb|center|200px]]

Binome2019-9

2020-04-09T15:18:20Z

Bblack : /* Clé USB */

Fichier:Registre a decalage.png

2020-04-09T15:16:21Z

Bblack : Bblack a téléversé une nouvelle version de Fichier:Registre a decalage.png

Fichier:Registre a decalage.png

2020-04-09T15:15:51Z

Bblack :

Binome2019-9

2020-04-09T15:15:38Z

Bblack : /* Clé USB */

Binome2019-9

2020-04-09T15:14:52Z

Bblack : /* Clé USB */

Binome2019-9

2020-04-09T15:14:03Z

Bblack : /* Clé USB */

Binome2019-9

2020-04-09T15:07:34Z

Bblack : /* Clé USB */

Binome2019-9

2020-04-09T15:06:02Z

Bblack : /* Clé USB */

Binome2019-9

2020-04-09T15:05:00Z

Bblack : /* Clé USB */

Binome2019-9

2020-04-09T15:02:59Z

Bblack :

Binome2019-9

2020-04-09T15:02:30Z

Bblack : /* Projet Intermédiaire: Le dé électronique */

Binome2019-9

2020-04-09T14:59:18Z

Bblack : /* Projet Intermédiaire: Le dé électronique */

Fichier:Circuit de 1.zip

2020-04-09T14:56:47Z

Bblack :

Binome2019-9

2020-04-09T14:56:21Z

Bblack : /* Projet Intermédiaire: Le dé électronique */

Binome2019-9

2020-03-30T08:20:01Z

Bblack :

Binome2019-9

2020-03-30T08:17:55Z

Bblack :

Binome2019-9

2020-03-30T08:16:23Z

Bblack : /* Introduction */

/*Introduction*/
Dans ce BE, l'objectif est de réaliser une clé usb avoir une ou plusieurs fonctionnalités originales. La première partie est donc de réflechir à différentes idées de fonctions à introduire sur cette clé.

----

=Partie Réflexion=

Le principal objectif est de tenter d'imbriquer des clés par le biais d'un hub.

Nous avons aussi plusieurs idées de fonctionnalités originales de la clé USB :

*un haut-parleur (bruitage lors du remplissage, de la connexion, etc)
*vumètre à LED
*Dévérouillage de la clé via un mot de passe, on scinde la clé en 2 parties, la première ayant un stockage minimal servant à la demande du mot de passe, l'autre utile pour le stockage et l'échange d'informations. (bip d'erreur en cas d'échec du mot de passe)
*ajouter de la mémoire via un SHIELD

=Composants=

*Le coeur qui va être un micro-contrôleur AVR plus exactement l'ATMega16u2.
*une mémoire faible capacité (64Mb) avec l'AT45DB641E-SHN2B-T ou une grande capacité mais plus difficile à souder (128Gb) avec l'MT29F128G8

TUSB4041I Four-Port USB 2.0 Hub

= Test ReX 15/03/2020 =
Après quelques soudures le programme suivant passe sur l'ATtiny84 :

#define MAX_LED 7
int leds[]={0,1,2,3,4,5,6};
void setup() {
int i;
for(i=0;i<MAX_LED;i++) pinMode(leds[i], OUTPUT);
}
void loop() {
int i;
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], HIGH);
delay(1000);
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], LOW);
delay(1000);
}

Démonstration de l'exécution : [[media:binome2019-9-test1.mp4]].

= Projet Intermédiaire: Le dé électronique=

Ce projet nous a permis de prendre en main le logiciel Fritzing et Arduino IDE.

Tout d'abord nous avons élaboré les plans de notre dé en vue schématique, ce qui nous permet d'y voir plus clair et de mieux comprendre notre carte.
Après avoir effectué notre schématique (schéma1), celui-ci est indispensable car des que l'on se retrouve avec beaucoup de composant, on s'y perd facilement, l'erreur est donc plus facilement detectable et il est conseiller d'utiliser des label pour facilité la comprehension.
Le schéma finit, il faut maintenant agencer les composants de sorte qu'aucunes pistes ne se croisent sur notre circuit imprimé (schéma 2).

Voici une photo de la vue schématique et du circuit imprimé

[[Fichier:schéma1_de.jpg|thumb|center|200px]]
[[Fichier:schéma 2 de.jpg|thumb|center|200px]]
[[Fichier:schéma 3 de.jpg|thumb|center|200px]]

Par la suite nos avons soudé sur notre circuit les 7 leds et 7 résistances, un travail très minutieux et assez compliqué.

Il ne reste plus qu'a coder notre microcontroleur, pour ce faire on utilise l'Arduino IDE

Le voici:

//========FONCTIONS PERSONALISEES - Il s'agit de fonctions créées sur mesure pour nos besoins

void toutEteindre() { //Cette fonction permet d'éteindre toutes les leds. Elle est de type "void" car elle ne revoit aucune valeur: elle se content d'exécuter les instructions.
digitalWrite(0, LOW); //Eteindre la led 1
digitalWrite(1, LOW); //Eteindre la led 2
digitalWrite(2, LOW); //Eteindre la led 3
digitalWrite(3, LOW); //Eteindre la led 4
digitalWrite(4, LOW); //Eteindre la led 5
digitalWrite(5, LOW); //Eteindre la led 6
digitalWrite(6, LOW); //Eteindre la led 7
}

void afficher(int nb) { //Cette fonction permet d'allumer les bonnes leds en fonction du nombre choisi.
//Elle prend en paramètre le nombre que l'on veut afficher.
switch (nb) { //C'est pareil qu'un if sauf que le if prend que des valeurs booléennes
case 1:
digitalWrite(4, HIGH);
break;
case 2:
digitalWrite(1, HIGH);
digitalWrite(6, HIGH);
break;
case 3:
digitalWrite(0, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
break;
case 4:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
break;
case 5:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
digitalWrite(4, HIGH);
break;
case 6:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
break;
}
}

int chercher() {
return random(1, 7);
}

//=================================================

void setup() {
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9,INPUT_PULLUP);
}

void loop() {
if (digitalRead(9) == LOW) {

for (int i = 1; i <= random(8, 15); i++) { // On fait defiler plusieurs nombre pour le suspens
afficher(chercher());
delay(200);
toutEteindre();
}
afficher(chercher()); //On affiche le "vrai" chiffre.
delay(3000);
toutEteindre();

}
}

Le résultat final en vidéo et quelques photos de notre circuit imprimé final: [[Fichier: 20200328_165241.mp4|thumb|center|200px]]

[[Fichier:Photo1 de.jpg|thumb|center|200px]]
[[Fichier: photo2 de.jpg|thumb|center|200px]]

Fichier:Photo2 de.jpg

2020-03-30T08:12:24Z

Bblack :

Binome2019-9

2020-03-30T08:11:59Z

Bblack : /* Projet Intermédiaire: Le dé électronique */

=Introduction=
Dans ce BE, l'objectif est de réaliser une clé usb avoir une ou plusieurs fonctionnalités originales. La première partie est donc de réflechir à différentes idées de fonctions à introduire sur cette clé.

----

=Partie Réflexion=

Le principal objectif est de tenter d'imbriquer des clés par le biais d'un hub.

Nous avons aussi plusieurs idées de fonctionnalités originales de la clé USB :

*un haut-parleur (bruitage lors du remplissage, de la connexion, etc)
*vumètre à LED
*Dévérouillage de la clé via un mot de passe, on scinde la clé en 2 parties, la première ayant un stockage minimal servant à la demande du mot de passe, l'autre utile pour le stockage et l'échange d'informations. (bip d'erreur en cas d'échec du mot de passe)
*ajouter de la mémoire via un SHIELD

=Composants=

*Le coeur qui va être un micro-contrôleur AVR plus exactement l'ATMega16u2.
*une mémoire faible capacité (64Mb) avec l'AT45DB641E-SHN2B-T ou une grande capacité mais plus difficile à souder (128Gb) avec l'MT29F128G8

TUSB4041I Four-Port USB 2.0 Hub

= Test ReX 15/03/2020 =
Après quelques soudures le programme suivant passe sur l'ATtiny84 :

#define MAX_LED 7
int leds[]={0,1,2,3,4,5,6};
void setup() {
int i;
for(i=0;i<MAX_LED;i++) pinMode(leds[i], OUTPUT);
}
void loop() {
int i;
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], HIGH);
delay(1000);
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], LOW);
delay(1000);
}

Démonstration de l'exécution : [[media:binome2019-9-test1.mp4]].

= Projet Intermédiaire: Le dé électronique=

Ce projet nous a permis de prendre en main le logiciel Fritzing et Arduino IDE.

Tout d'abord nous avons élaboré les plans de notre dé en vue schématique, ce qui nous permet d'y voir plus clair et de mieux comprendre notre carte.
Après avoir effectué notre schématique (schéma1), celui-ci est indispensable car des que l'on se retrouve avec beaucoup de composant, on s'y perd facilement, l'erreur est donc plus facilement detectable et il est conseiller d'utiliser des label pour facilité la comprehension.
Le schéma finit, il faut maintenant agencer les composants de sorte qu'aucunes pistes ne se croisent sur notre circuit imprimé (schéma 2).

Voici une photo de la vue schématique et du circuit imprimé

[[Fichier:schéma1_de.jpg|thumb|center|200px]]
[[Fichier:schéma 2 de.jpg|thumb|center|200px]]
[[Fichier:schéma 3 de.jpg|thumb|center|200px]]

Par la suite nos avons soudé sur notre circuit les 7 leds et 7 résistances, un travail très minutieux et assez compliqué.

Il ne reste plus qu'a coder notre microcontroleur, pour ce faire on utilise l'Arduino IDE

Le voici:

//========FONCTIONS PERSONALISEES - Il s'agit de fonctions créées sur mesure pour nos besoins

void toutEteindre() { //Cette fonction permet d'éteindre toutes les leds. Elle est de type "void" car elle ne revoit aucune valeur: elle se content d'exécuter les instructions.
digitalWrite(0, LOW); //Eteindre la led 1
digitalWrite(1, LOW); //Eteindre la led 2
digitalWrite(2, LOW); //Eteindre la led 3
digitalWrite(3, LOW); //Eteindre la led 4
digitalWrite(4, LOW); //Eteindre la led 5
digitalWrite(5, LOW); //Eteindre la led 6
digitalWrite(6, LOW); //Eteindre la led 7
}

void afficher(int nb) { //Cette fonction permet d'allumer les bonnes leds en fonction du nombre choisi.
//Elle prend en paramètre le nombre que l'on veut afficher.
switch (nb) { //C'est pareil qu'un if sauf que le if prend que des valeurs booléennes
case 1:
digitalWrite(4, HIGH);
break;
case 2:
digitalWrite(1, HIGH);
digitalWrite(6, HIGH);
break;
case 3:
digitalWrite(0, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
break;
case 4:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
break;
case 5:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
digitalWrite(4, HIGH);
break;
case 6:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
break;
}
}

int chercher() {
return random(1, 7);
}

//=================================================

void setup() {
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9,INPUT_PULLUP);
}

void loop() {
if (digitalRead(9) == LOW) {

for (int i = 1; i <= random(8, 15); i++) { // On fait defiler plusieurs nombre pour le suspens
afficher(chercher());
delay(200);
toutEteindre();
}
afficher(chercher()); //On affiche le "vrai" chiffre.
delay(3000);
toutEteindre();

}
}

Le résultat final en vidéo et quelques photos de notre circuit imprimé final: [[Fichier: 20200328_165241.mp4|thumb|center|200px]]

[[Fichier:Photo1 de.jpg|thumb|center|200px]]
[[Fichier: photo2 de.jpg|thumb|center|200px]]

Binome2019-9

2020-03-30T08:10:08Z

Bblack : /* Projet Intermédiaire: Le dé électronique */

Fichier:Schéma 3 de.jpg

2020-03-30T08:08:53Z

Bblack :

Fichier:Schéma 2 de.jpg

2020-03-30T08:08:22Z

Bblack :

Fichier:Schéma1 de.jpg

2020-03-30T08:07:49Z

Bblack : Bblack a téléversé une nouvelle version de Fichier:Schéma1 de.jpg

Fichier:Schéma1 de.jpg

2020-03-30T08:07:04Z

Bblack :

Binome2019-9

2020-03-30T08:06:41Z

Bblack : /* Projet Intermédiaire: Le dé électronique */

Fichier:Schéma 1.jpg

2020-03-30T08:05:27Z

Bblack :

Fichier:Schéma 1.png

2020-03-30T08:02:45Z

Bblack : Bblack a téléversé une nouvelle version de Fichier:Schéma 1.png

Binome2019-9

2020-03-30T08:01:52Z

Bblack : /* Projet Intermédiaire: Le dé électronique */

=Introduction=
Dans ce BE, l'objectif est de réaliser une clé usb avoir une ou plusieurs fonctionnalités originales. La première partie est donc de réflechir à différentes idées de fonctions à introduire sur cette clé.

----

=Partie Réflexion=

Le principal objectif est de tenter d'imbriquer des clés par le biais d'un hub.

Nous avons aussi plusieurs idées de fonctionnalités originales de la clé USB :

*un haut-parleur (bruitage lors du remplissage, de la connexion, etc)
*vumètre à LED
*Dévérouillage de la clé via un mot de passe, on scinde la clé en 2 parties, la première ayant un stockage minimal servant à la demande du mot de passe, l'autre utile pour le stockage et l'échange d'informations. (bip d'erreur en cas d'échec du mot de passe)
*ajouter de la mémoire via un SHIELD

=Composants=

*Le coeur qui va être un micro-contrôleur AVR plus exactement l'ATMega16u2.
*une mémoire faible capacité (64Mb) avec l'AT45DB641E-SHN2B-T ou une grande capacité mais plus difficile à souder (128Gb) avec l'MT29F128G8

TUSB4041I Four-Port USB 2.0 Hub

= Test ReX 15/03/2020 =
Après quelques soudures le programme suivant passe sur l'ATtiny84 :

#define MAX_LED 7
int leds[]={0,1,2,3,4,5,6};
void setup() {
int i;
for(i=0;i<MAX_LED;i++) pinMode(leds[i], OUTPUT);
}
void loop() {
int i;
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], HIGH);
delay(1000);
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], LOW);
delay(1000);
}

Démonstration de l'exécution : [[media:binome2019-9-test1.mp4]].

= Projet Intermédiaire: Le dé électronique=

Ce projet nous a permis de prendre en main le logiciel Fritzing et Arduino IDE.

Tout d'abord nous avons élaboré les plans de notre dé en vue schématique, ce qui nous permet d'y voir plus clair et de mieux comprendre notre carte.
Après avoir effectué notre schématique (schéma1), celui-ci est indispensable car des que l'on se retrouve avec beaucoup de composant, on s'y perd facilement, l'erreur est donc plus facilement detectable et il est conseiller d'utiliser des label pour facilité la comprehension.
Le schéma finit, il faut maintenant agencer les composants de sorte qu'aucunes pistes ne se croisent sur notre circuit imprimé (schéma 2).

Voici une photo de la vue schématique et du circuit imprimé

[[Fichier:schéma 1.jpg|thumb|center|200px]]
[[Fichier:schéma 2.jpg|thumb|center|200px]]
[[Fichier:schéma 3.jpg|thumb|center|200px]]

Par la suite nos avons soudé sur notre circuit les 7 leds et 7 résistances, un travail très minutieux et assez compliqué.

Il ne reste plus qu'a coder notre microcontroleur, pour ce faire on utilise l'Arduino IDE

Le voici:

//========FONCTIONS PERSONALISEES - Il s'agit de fonctions créées sur mesure pour nos besoins

void toutEteindre() { //Cette fonction permet d'éteindre toutes les leds. Elle est de type "void" car elle ne revoit aucune valeur: elle se content d'exécuter les instructions.
digitalWrite(0, LOW); //Eteindre la led 1
digitalWrite(1, LOW); //Eteindre la led 2
digitalWrite(2, LOW); //Eteindre la led 3
digitalWrite(3, LOW); //Eteindre la led 4
digitalWrite(4, LOW); //Eteindre la led 5
digitalWrite(5, LOW); //Eteindre la led 6
digitalWrite(6, LOW); //Eteindre la led 7
}

void afficher(int nb) { //Cette fonction permet d'allumer les bonnes leds en fonction du nombre choisi.
//Elle prend en paramètre le nombre que l'on veut afficher.
switch (nb) { //C'est pareil qu'un if sauf que le if prend que des valeurs booléennes
case 1:
digitalWrite(4, HIGH);
break;
case 2:
digitalWrite(1, HIGH);
digitalWrite(6, HIGH);
break;
case 3:
digitalWrite(0, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
break;
case 4:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
break;
case 5:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
digitalWrite(4, HIGH);
break;
case 6:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
break;
}
}

int chercher() {
return random(1, 7);
}

//=================================================

void setup() {
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9,INPUT_PULLUP);
}

void loop() {
if (digitalRead(9) == LOW) {

for (int i = 1; i <= random(8, 15); i++) { // On fait defiler plusieurs nombre pour le suspens
afficher(chercher());
delay(200);
toutEteindre();
}
afficher(chercher()); //On affiche le "vrai" chiffre.
delay(3000);
toutEteindre();

}
}

Le résultat final en vidéo et quelques photos de notre circuit imprimé final: [[Fichier: 20200328_165241.mp4|thumb|center|200px]]

[[Fichier:Photo1 de.jpg|thumb|center|200px]]
[[Fichier: photo2.png|thumb|center|200px]]

Binome2019-9

2020-03-30T07:59:09Z

Bblack : /* Projet Intermédiaire: Le dé électronique */

=Introduction=
Dans ce BE, l'objectif est de réaliser une clé usb avoir une ou plusieurs fonctionnalités originales. La première partie est donc de réflechir à différentes idées de fonctions à introduire sur cette clé.

----

=Partie Réflexion=

Le principal objectif est de tenter d'imbriquer des clés par le biais d'un hub.

Nous avons aussi plusieurs idées de fonctionnalités originales de la clé USB :

*un haut-parleur (bruitage lors du remplissage, de la connexion, etc)
*vumètre à LED
*Dévérouillage de la clé via un mot de passe, on scinde la clé en 2 parties, la première ayant un stockage minimal servant à la demande du mot de passe, l'autre utile pour le stockage et l'échange d'informations. (bip d'erreur en cas d'échec du mot de passe)
*ajouter de la mémoire via un SHIELD

=Composants=

*Le coeur qui va être un micro-contrôleur AVR plus exactement l'ATMega16u2.
*une mémoire faible capacité (64Mb) avec l'AT45DB641E-SHN2B-T ou une grande capacité mais plus difficile à souder (128Gb) avec l'MT29F128G8

TUSB4041I Four-Port USB 2.0 Hub

= Test ReX 15/03/2020 =
Après quelques soudures le programme suivant passe sur l'ATtiny84 :

#define MAX_LED 7
int leds[]={0,1,2,3,4,5,6};
void setup() {
int i;
for(i=0;i<MAX_LED;i++) pinMode(leds[i], OUTPUT);
}
void loop() {
int i;
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], HIGH);
delay(1000);
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], LOW);
delay(1000);
}

Démonstration de l'exécution : [[media:binome2019-9-test1.mp4]].

= Projet Intermédiaire: Le dé électronique=

Ce projet nous a permis de prendre en main le logiciel Fritzing et Arduino IDE.

Tout d'abord nous avons élaboré les plans de notre dé en vue schématique, ce qui nous permet d'y voir plus clair et de mieux comprendre notre carte.
Après avoir effectué notre schématique (schéma1), celui-ci est indispensable car des que l'on se retrouve avec beaucoup de composant, on s'y perd facilement, l'erreur est donc plus facilement detectable et il est conseiller d'utiliser des label pour facilité la comprehension.
Le schéma finit, il faut maintenant agencer les composants de sorte qu'aucunes pistes ne se croisent sur notre circuit imprimé (schéma 2).

Voici une photo de la vue schématique et du circuit imprimé

[[Fichier:schéma 1.jpeg|thumb|center|200px]]
[[Fichier:schéma 2.jpeg|thumb|center|200px]]
[[Fichier:schéma 3.jpeg|thumb|center|200px]]

Par la suite nos avons soudé sur notre circuit les 7 leds et 7 résistances, un travail très minutieux et assez compliqué.

Il ne reste plus qu'a coder notre microcontroleur, pour ce faire on utilise l'Arduino IDE

Le voici:

//========FONCTIONS PERSONALISEES - Il s'agit de fonctions créées sur mesure pour nos besoins

void toutEteindre() { //Cette fonction permet d'éteindre toutes les leds. Elle est de type "void" car elle ne revoit aucune valeur: elle se content d'exécuter les instructions.
digitalWrite(0, LOW); //Eteindre la led 1
digitalWrite(1, LOW); //Eteindre la led 2
digitalWrite(2, LOW); //Eteindre la led 3
digitalWrite(3, LOW); //Eteindre la led 4
digitalWrite(4, LOW); //Eteindre la led 5
digitalWrite(5, LOW); //Eteindre la led 6
digitalWrite(6, LOW); //Eteindre la led 7
}

void afficher(int nb) { //Cette fonction permet d'allumer les bonnes leds en fonction du nombre choisi.
//Elle prend en paramètre le nombre que l'on veut afficher.
switch (nb) { //C'est pareil qu'un if sauf que le if prend que des valeurs booléennes
case 1:
digitalWrite(4, HIGH);
break;
case 2:
digitalWrite(1, HIGH);
digitalWrite(6, HIGH);
break;
case 3:
digitalWrite(0, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
break;
case 4:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
break;
case 5:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
digitalWrite(4, HIGH);
break;
case 6:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
break;
}
}

int chercher() {
return random(1, 7);
}

//=================================================

void setup() {
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9,INPUT_PULLUP);
}

void loop() {
if (digitalRead(9) == LOW) {

for (int i = 1; i <= random(8, 15); i++) { // On fait defiler plusieurs nombre pour le suspens
afficher(chercher());
delay(200);
toutEteindre();
}
afficher(chercher()); //On affiche le "vrai" chiffre.
delay(3000);
toutEteindre();

}
}

Le résultat final en vidéo et quelques photos de notre circuit imprimé final: [[Fichier: 20200328_165241.mp4|thumb|center|200px]]

[[Fichier:Photo1 de.jpg|thumb|center|200px]]
[[Fichier: photo2.png|thumb|center|200px]]

Binome2019-9

2020-03-30T07:57:34Z

Bblack : /* Projet Intermédiaire: Le dé électronique */

=Introduction=
Dans ce BE, l'objectif est de réaliser une clé usb avoir une ou plusieurs fonctionnalités originales. La première partie est donc de réflechir à différentes idées de fonctions à introduire sur cette clé.

----

=Partie Réflexion=

Le principal objectif est de tenter d'imbriquer des clés par le biais d'un hub.

Nous avons aussi plusieurs idées de fonctionnalités originales de la clé USB :

*un haut-parleur (bruitage lors du remplissage, de la connexion, etc)
*vumètre à LED
*Dévérouillage de la clé via un mot de passe, on scinde la clé en 2 parties, la première ayant un stockage minimal servant à la demande du mot de passe, l'autre utile pour le stockage et l'échange d'informations. (bip d'erreur en cas d'échec du mot de passe)
*ajouter de la mémoire via un SHIELD

=Composants=

*Le coeur qui va être un micro-contrôleur AVR plus exactement l'ATMega16u2.
*une mémoire faible capacité (64Mb) avec l'AT45DB641E-SHN2B-T ou une grande capacité mais plus difficile à souder (128Gb) avec l'MT29F128G8

TUSB4041I Four-Port USB 2.0 Hub

= Test ReX 15/03/2020 =
Après quelques soudures le programme suivant passe sur l'ATtiny84 :

#define MAX_LED 7
int leds[]={0,1,2,3,4,5,6};
void setup() {
int i;
for(i=0;i<MAX_LED;i++) pinMode(leds[i], OUTPUT);
}
void loop() {
int i;
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], HIGH);
delay(1000);
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], LOW);
delay(1000);
}

Démonstration de l'exécution : [[media:binome2019-9-test1.mp4]].

= Projet Intermédiaire: Le dé électronique=

Ce projet nous a permis de prendre en main le logiciel Fritzing et Arduino IDE.

Tout d'abord nous avons élaboré les plans de notre dé en vue schématique, ce qui nous permet d'y voir plus clair et de mieux comprendre notre carte.
Après avoir effectué notre schématique (schéma1), celui-ci est indispensable car des que l'on se retrouve avec beaucoup de composant, on s'y perd facilement, l'erreur est donc plus facilement detectable et il est conseiller d'utiliser des label pour facilité la comprehension.
Le schéma finit, il faut maintenant agencer les composants de sorte qu'aucunes pistes ne se croisent sur notre circuit imprimé (schéma 2).

Voici une photo de la vue schématique et du circuit imprimé

[[Fichier:schéma 1.jpg|thumb|center|200px]]
[[Fichier:schéma 2.jpg|thumb|center|200px]]
[[Fichier:schéma 3.jpg|thumb|center|200px]]

Par la suite nos avons soudé sur notre circuit les 7 leds et 7 résistances, un travail très minutieux et assez compliqué.

Il ne reste plus qu'a coder notre microcontroleur, pour ce faire on utilise l'Arduino IDE

Le voici:

//========FONCTIONS PERSONALISEES - Il s'agit de fonctions créées sur mesure pour nos besoins

void toutEteindre() { //Cette fonction permet d'éteindre toutes les leds. Elle est de type "void" car elle ne revoit aucune valeur: elle se content d'exécuter les instructions.
digitalWrite(0, LOW); //Eteindre la led 1
digitalWrite(1, LOW); //Eteindre la led 2
digitalWrite(2, LOW); //Eteindre la led 3
digitalWrite(3, LOW); //Eteindre la led 4
digitalWrite(4, LOW); //Eteindre la led 5
digitalWrite(5, LOW); //Eteindre la led 6
digitalWrite(6, LOW); //Eteindre la led 7
}

void afficher(int nb) { //Cette fonction permet d'allumer les bonnes leds en fonction du nombre choisi.
//Elle prend en paramètre le nombre que l'on veut afficher.
switch (nb) { //C'est pareil qu'un if sauf que le if prend que des valeurs booléennes
case 1:
digitalWrite(4, HIGH);
break;
case 2:
digitalWrite(1, HIGH);
digitalWrite(6, HIGH);
break;
case 3:
digitalWrite(0, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
break;
case 4:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
break;
case 5:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
digitalWrite(4, HIGH);
break;
case 6:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
break;
}
}

int chercher() {
return random(1, 7);
}

//=================================================

void setup() {
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9,INPUT_PULLUP);
}

void loop() {
if (digitalRead(9) == LOW) {

for (int i = 1; i <= random(8, 15); i++) { // On fait defiler plusieurs nombre pour le suspens
afficher(chercher());
delay(200);
toutEteindre();
}
afficher(chercher()); //On affiche le "vrai" chiffre.
delay(3000);
toutEteindre();

}
}

Le résultat final en vidéo et quelques photos de notre circuit imprimé final: [[Fichier: 20200328_165241.mp4|thumb|center|200px]]

[[Fichier:Photo1 de.jpg|thumb|center|200px]]
[[Fichier: photo2.png|thumb|center|200px]]

Binome2019-9

2020-03-30T07:55:42Z

Bblack : /* Projet Intermédiaire: Le dé électronique */

=Introduction=
Dans ce BE, l'objectif est de réaliser une clé usb avoir une ou plusieurs fonctionnalités originales. La première partie est donc de réflechir à différentes idées de fonctions à introduire sur cette clé.

----

=Partie Réflexion=

Le principal objectif est de tenter d'imbriquer des clés par le biais d'un hub.

Nous avons aussi plusieurs idées de fonctionnalités originales de la clé USB :

*un haut-parleur (bruitage lors du remplissage, de la connexion, etc)
*vumètre à LED
*Dévérouillage de la clé via un mot de passe, on scinde la clé en 2 parties, la première ayant un stockage minimal servant à la demande du mot de passe, l'autre utile pour le stockage et l'échange d'informations. (bip d'erreur en cas d'échec du mot de passe)
*ajouter de la mémoire via un SHIELD

=Composants=

*Le coeur qui va être un micro-contrôleur AVR plus exactement l'ATMega16u2.
*une mémoire faible capacité (64Mb) avec l'AT45DB641E-SHN2B-T ou une grande capacité mais plus difficile à souder (128Gb) avec l'MT29F128G8

TUSB4041I Four-Port USB 2.0 Hub

= Test ReX 15/03/2020 =
Après quelques soudures le programme suivant passe sur l'ATtiny84 :

#define MAX_LED 7
int leds[]={0,1,2,3,4,5,6};
void setup() {
int i;
for(i=0;i<MAX_LED;i++) pinMode(leds[i], OUTPUT);
}
void loop() {
int i;
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], HIGH);
delay(1000);
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], LOW);
delay(1000);
}

Démonstration de l'exécution : [[media:binome2019-9-test1.mp4]].

= Projet Intermédiaire: Le dé électronique=

Ce projet nous a permis de prendre en main le logiciel Fritzing et Arduino IDE.

Tout d'abord nous avons élaboré les plans de notre dé en vue schématique, ce qui nous permet d'y voir plus clair et de mieux comprendre notre carte.
Après avoir effectué notre schématique (schéma1), celui-ci est indispensable car des que l'on se retrouve avec beaucoup de composant, on s'y perd facilement, l'erreur est donc plus facilement detectable et il est conseiller d'utiliser des label pour facilité la comprehension.
Le schéma finit, il faut maintenant agencer les composants de sorte qu'aucunes pistes ne se croisent sur notre circuit imprimé (schéma 2).

Voici une photo de la vue schématique et du circuit imprimé

[[Fichier:schéma 1|thumb|center|200px]]
[[Fichier:schéma 2.png|thumb|center|200px]]

Par la suite nos avons soudé sur notre circuit les 7 leds et 7 résistances, un travail très minutieux et assez compliqué.

Il ne reste plus qu'a coder notre microcontroleur, pour ce faire on utilise l'Arduino IDE

Le voici:

//========FONCTIONS PERSONALISEES - Il s'agit de fonctions créées sur mesure pour nos besoins

void toutEteindre() { //Cette fonction permet d'éteindre toutes les leds. Elle est de type "void" car elle ne revoit aucune valeur: elle se content d'exécuter les instructions.
digitalWrite(0, LOW); //Eteindre la led 1
digitalWrite(1, LOW); //Eteindre la led 2
digitalWrite(2, LOW); //Eteindre la led 3
digitalWrite(3, LOW); //Eteindre la led 4
digitalWrite(4, LOW); //Eteindre la led 5
digitalWrite(5, LOW); //Eteindre la led 6
digitalWrite(6, LOW); //Eteindre la led 7
}

void afficher(int nb) { //Cette fonction permet d'allumer les bonnes leds en fonction du nombre choisi.
//Elle prend en paramètre le nombre que l'on veut afficher.
switch (nb) { //C'est pareil qu'un if sauf que le if prend que des valeurs booléennes
case 1:
digitalWrite(4, HIGH);
break;
case 2:
digitalWrite(1, HIGH);
digitalWrite(6, HIGH);
break;
case 3:
digitalWrite(0, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
break;
case 4:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
break;
case 5:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
digitalWrite(4, HIGH);
break;
case 6:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
break;
}
}

int chercher() {
return random(1, 7);
}

//=================================================

void setup() {
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9,INPUT_PULLUP);
}

void loop() {
if (digitalRead(9) == LOW) {

for (int i = 1; i <= random(8, 15); i++) { // On fait defiler plusieurs nombre pour le suspens
afficher(chercher());
delay(200);
toutEteindre();
}
afficher(chercher()); //On affiche le "vrai" chiffre.
delay(3000);
toutEteindre();

}
}

Le résultat final en vidéo et quelques photos de notre circuit imprimé final: [[Fichier: 20200328_165241.mp4|thumb|center|200px]]

[[Fichier:Photo1 de.jpg|thumb|center|200px]]
[[Fichier: photo2.png|thumb|center|200px]]

Binome2019-9

2020-03-30T07:54:07Z

Bblack : /* Projet Intermédiaire: Le dé électronique */

=Introduction=
Dans ce BE, l'objectif est de réaliser une clé usb avoir une ou plusieurs fonctionnalités originales. La première partie est donc de réflechir à différentes idées de fonctions à introduire sur cette clé.

----

=Partie Réflexion=

Le principal objectif est de tenter d'imbriquer des clés par le biais d'un hub.

Nous avons aussi plusieurs idées de fonctionnalités originales de la clé USB :

*un haut-parleur (bruitage lors du remplissage, de la connexion, etc)
*vumètre à LED
*Dévérouillage de la clé via un mot de passe, on scinde la clé en 2 parties, la première ayant un stockage minimal servant à la demande du mot de passe, l'autre utile pour le stockage et l'échange d'informations. (bip d'erreur en cas d'échec du mot de passe)
*ajouter de la mémoire via un SHIELD

=Composants=

*Le coeur qui va être un micro-contrôleur AVR plus exactement l'ATMega16u2.
*une mémoire faible capacité (64Mb) avec l'AT45DB641E-SHN2B-T ou une grande capacité mais plus difficile à souder (128Gb) avec l'MT29F128G8

TUSB4041I Four-Port USB 2.0 Hub

= Test ReX 15/03/2020 =
Après quelques soudures le programme suivant passe sur l'ATtiny84 :

#define MAX_LED 7
int leds[]={0,1,2,3,4,5,6};
void setup() {
int i;
for(i=0;i<MAX_LED;i++) pinMode(leds[i], OUTPUT);
}
void loop() {
int i;
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], HIGH);
delay(1000);
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], LOW);
delay(1000);
}

Démonstration de l'exécution : [[media:binome2019-9-test1.mp4]].

= Projet Intermédiaire: Le dé électronique=

Ce projet nous a permis de prendre en main le logiciel Fritzing et Arduino IDE.

Tout d'abord nous avons élaboré les plans de notre dé en vue schématique, ce qui nous permet d'y voir plus clair et de mieux comprendre notre carte.
Après avoir effectué notre schématique (schéma1), celui-ci est indispensable car des que l'on se retrouve avec beaucoup de composant, on s'y perd facilement, l'erreur est donc plus facilement detectable et il est conseiller d'utiliser des label pour facilité la comprehension.
Le schéma finit, il faut maintenant agencer les composants de sorte qu'aucunes pistes ne se croisent sur notre circuit imprimé (schéma 2).

Voici une photo de la vue schématique et du circuit imprimé

[[Fichier:Photo1 de.jpg|thumb|center|200px]]
[[Fichier:schéma 2.png|thumb|center|200px]]

Par la suite nos avons soudé sur notre circuit les 7 leds et 7 résistances, un travail très minutieux et assez compliqué.

Il ne reste plus qu'a coder notre microcontroleur, pour ce faire on utilise l'Arduino IDE

Le voici:

//========FONCTIONS PERSONALISEES - Il s'agit de fonctions créées sur mesure pour nos besoins

void toutEteindre() { //Cette fonction permet d'éteindre toutes les leds. Elle est de type "void" car elle ne revoit aucune valeur: elle se content d'exécuter les instructions.
digitalWrite(0, LOW); //Eteindre la led 1
digitalWrite(1, LOW); //Eteindre la led 2
digitalWrite(2, LOW); //Eteindre la led 3
digitalWrite(3, LOW); //Eteindre la led 4
digitalWrite(4, LOW); //Eteindre la led 5
digitalWrite(5, LOW); //Eteindre la led 6
digitalWrite(6, LOW); //Eteindre la led 7
}

void afficher(int nb) { //Cette fonction permet d'allumer les bonnes leds en fonction du nombre choisi.
//Elle prend en paramètre le nombre que l'on veut afficher.
switch (nb) { //C'est pareil qu'un if sauf que le if prend que des valeurs booléennes
case 1:
digitalWrite(4, HIGH);
break;
case 2:
digitalWrite(1, HIGH);
digitalWrite(6, HIGH);
break;
case 3:
digitalWrite(0, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
break;
case 4:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
break;
case 5:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
digitalWrite(4, HIGH);
break;
case 6:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
break;
}
}

int chercher() {
return random(1, 7);
}

//=================================================

void setup() {
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9,INPUT_PULLUP);
}

void loop() {
if (digitalRead(9) == LOW) {

for (int i = 1; i <= random(8, 15); i++) { // On fait defiler plusieurs nombre pour le suspens
afficher(chercher());
delay(200);
toutEteindre();
}
afficher(chercher()); //On affiche le "vrai" chiffre.
delay(3000);
toutEteindre();

}
}

Le résultat final en vidéo et quelques photos de notre circuit imprimé final: [[Fichier: 20200328_165241.mp4|thumb|center|200px]]

[[Fichier: photo1.png|thumb|center|200px]]
[[Fichier: photo2.png|thumb|center|200px]]

Fichier:Photo1 de.jpg

2020-03-30T07:50:37Z

Bblack :

Binome2019-9

2020-03-30T07:44:26Z

Bblack : /* Projet Intermédiaire: Le dé électronique */

=Introduction=
Dans ce BE, l'objectif est de réaliser une clé usb avoir une ou plusieurs fonctionnalités originales. La première partie est donc de réflechir à différentes idées de fonctions à introduire sur cette clé.

----

=Partie Réflexion=

Le principal objectif est de tenter d'imbriquer des clés par le biais d'un hub.

Nous avons aussi plusieurs idées de fonctionnalités originales de la clé USB :

*un haut-parleur (bruitage lors du remplissage, de la connexion, etc)
*vumètre à LED
*Dévérouillage de la clé via un mot de passe, on scinde la clé en 2 parties, la première ayant un stockage minimal servant à la demande du mot de passe, l'autre utile pour le stockage et l'échange d'informations. (bip d'erreur en cas d'échec du mot de passe)
*ajouter de la mémoire via un SHIELD

=Composants=

*Le coeur qui va être un micro-contrôleur AVR plus exactement l'ATMega16u2.
*une mémoire faible capacité (64Mb) avec l'AT45DB641E-SHN2B-T ou une grande capacité mais plus difficile à souder (128Gb) avec l'MT29F128G8

TUSB4041I Four-Port USB 2.0 Hub

= Test ReX 15/03/2020 =
Après quelques soudures le programme suivant passe sur l'ATtiny84 :

#define MAX_LED 7
int leds[]={0,1,2,3,4,5,6};
void setup() {
int i;
for(i=0;i<MAX_LED;i++) pinMode(leds[i], OUTPUT);
}
void loop() {
int i;
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], HIGH);
delay(1000);
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], LOW);
delay(1000);
}

Démonstration de l'exécution : [[media:binome2019-9-test1.mp4]].

= Projet Intermédiaire: Le dé électronique=

Ce projet nous a permis de prendre en main le logiciel Fritzing et Arduino IDE.

Tout d'abord nous avons élaboré les plans de notre dé en vue schématique, ce qui nous permet d'y voir plus clair et de mieux comprendre notre carte.
Après avoir effectué notre schématique (schéma1), celui-ci est indispensable car des que l'on se retrouve avec beaucoup de composant, on s'y perd facilement, l'erreur est donc plus facilement detectable et il est conseiller d'utiliser des label pour facilité la comprehension.
Le schéma finit, il faut maintenant agencer les composants de sorte qu'aucunes pistes ne se croisent sur notre circuit imprimé (schéma 2).

Voici une photo de la vue schématique et du circuit imprimé

[[Fichier:schéma 1.png|thumb|center|200px]]
[[Fichier:schéma 2.png|thumb|center|200px]]

Par la suite nos avons soudé sur notre circuit les 7 leds et 7 résistances, un travail très minutieux et assez compliqué.

Il ne reste plus qu'a coder notre microcontroleur, pour ce faire on utilise l'Arduino IDE

Le voici:

//========FONCTIONS PERSONALISEES - Il s'agit de fonctions créées sur mesure pour nos besoins

void toutEteindre() { //Cette fonction permet d'éteindre toutes les leds. Elle est de type "void" car elle ne revoit aucune valeur: elle se content d'exécuter les instructions.
digitalWrite(0, LOW); //Eteindre la led 1
digitalWrite(1, LOW); //Eteindre la led 2
digitalWrite(2, LOW); //Eteindre la led 3
digitalWrite(3, LOW); //Eteindre la led 4
digitalWrite(4, LOW); //Eteindre la led 5
digitalWrite(5, LOW); //Eteindre la led 6
digitalWrite(6, LOW); //Eteindre la led 7
}

void afficher(int nb) { //Cette fonction permet d'allumer les bonnes leds en fonction du nombre choisi.
//Elle prend en paramètre le nombre que l'on veut afficher.
switch (nb) { //C'est pareil qu'un if sauf que le if prend que des valeurs booléennes
case 1:
digitalWrite(4, HIGH);
break;
case 2:
digitalWrite(1, HIGH);
digitalWrite(6, HIGH);
break;
case 3:
digitalWrite(0, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
break;
case 4:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
break;
case 5:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
digitalWrite(4, HIGH);
break;
case 6:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
break;
}
}

int chercher() {
return random(1, 7);
}

//=================================================

void setup() {
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9,INPUT_PULLUP);
}

void loop() {
if (digitalRead(9) == LOW) {

for (int i = 1; i <= random(8, 15); i++) { // On fait defiler plusieurs nombre pour le suspens
afficher(chercher());
delay(200);
toutEteindre();
}
afficher(chercher()); //On affiche le "vrai" chiffre.
delay(3000);
toutEteindre();

}
}

Le résultat final en vidéo et quelques photos de notre circuit imprimé final: [[Fichier: 20200328_165241.mp4|thumb|center|200px]]

[[Fichier: photo1.png|thumb|center|200px]]
[[Fichier: photo2.png|thumb|center|200px]]

Fichier:20200328 165241.mp4

2020-03-30T07:41:09Z

Bblack :

Binome2019-9

2020-03-30T07:09:35Z

Bblack : /* Projet Intermédiaire: Le dé électronique */

=Introduction=
Dans ce BE, l'objectif est de réaliser une clé usb avoir une ou plusieurs fonctionnalités originales. La première partie est donc de réflechir à différentes idées de fonctions à introduire sur cette clé.

----

=Partie Réflexion=

Le principal objectif est de tenter d'imbriquer des clés par le biais d'un hub.

Nous avons aussi plusieurs idées de fonctionnalités originales de la clé USB :

*un haut-parleur (bruitage lors du remplissage, de la connexion, etc)
*vumètre à LED
*Dévérouillage de la clé via un mot de passe, on scinde la clé en 2 parties, la première ayant un stockage minimal servant à la demande du mot de passe, l'autre utile pour le stockage et l'échange d'informations. (bip d'erreur en cas d'échec du mot de passe)
*ajouter de la mémoire via un SHIELD

=Composants=

*Le coeur qui va être un micro-contrôleur AVR plus exactement l'ATMega16u2.
*une mémoire faible capacité (64Mb) avec l'AT45DB641E-SHN2B-T ou une grande capacité mais plus difficile à souder (128Gb) avec l'MT29F128G8

TUSB4041I Four-Port USB 2.0 Hub

= Test ReX 15/03/2020 =
Après quelques soudures le programme suivant passe sur l'ATtiny84 :

#define MAX_LED 7
int leds[]={0,1,2,3,4,5,6};
void setup() {
int i;
for(i=0;i<MAX_LED;i++) pinMode(leds[i], OUTPUT);
}
void loop() {
int i;
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], HIGH);
delay(1000);
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], LOW);
delay(1000);
}

Démonstration de l'exécution : [[media:binome2019-9-test1.mp4]].

= Projet Intermédiaire: Le dé électronique=

Ce projet nous a permis de prendre en main le logiciel Fritzing et Arduino IDE.

Tout d'abord nous avons élaboré les plans de notre dé en vue schématique, ce qui nous permet d'y voir plus clair et de mieux comprendre notre carte.
Après avoir effectué notre schématique (schéma1), celui-ci est indispensable car des que l'on se retrouve avec beaucoup de composant, on s'y perd facilement, l'erreur est donc plus facilement detectable et il est conseiller d'utiliser des label pour facilité la comprehension.
Le schéma finit, il faut maintenant agencer les composants de sorte qu'aucunes pistes ne se croisent sur notre circuit imprimé (schéma 2).

Voici une photo de la vue schématique et du circuit imprimé

[[Fichier:schéma 1.png|thumb|center|200px]]
[[Fichier:schéma 2.png|thumb|center|200px]]

Par la suite nos avons soudé sur notre circuit les 7 leds et 7 résistances, un travail très minutieux et assez compliqué.

Il ne reste plus qu'a coder notre microcontroleur, pour ce faire on utilise l'Arduino IDE

Le voici:

//========FONCTIONS PERSONALISEES - Il s'agit de fonctions créées sur mesure pour nos besoins

void toutEteindre() { //Cette fonction permet d'éteindre toutes les leds. Elle est de type "void" car elle ne revoit aucune valeur: elle se content d'exécuter les instructions.
digitalWrite(0, LOW); //Eteindre la led 1
digitalWrite(1, LOW); //Eteindre la led 2
digitalWrite(2, LOW); //Eteindre la led 3
digitalWrite(3, LOW); //Eteindre la led 4
digitalWrite(4, LOW); //Eteindre la led 5
digitalWrite(5, LOW); //Eteindre la led 6
digitalWrite(6, LOW); //Eteindre la led 7
}

void afficher(int nb) { //Cette fonction permet d'allumer les bonnes leds en fonction du nombre choisi.
//Elle prend en paramètre le nombre que l'on veut afficher.
switch (nb) { //C'est pareil qu'un if sauf que le if prend que des valeurs booléennes
case 1:
digitalWrite(4, HIGH);
break;
case 2:
digitalWrite(1, HIGH);
digitalWrite(6, HIGH);
break;
case 3:
digitalWrite(0, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
break;
case 4:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
break;
case 5:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
digitalWrite(4, HIGH);
break;
case 6:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
break;
}
}

int chercher() {
return random(1, 7);
}

//=================================================

void setup() {
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9,INPUT_PULLUP);
}

void loop() {
if (digitalRead(9) == LOW) {

for (int i = 1; i <= random(8, 15); i++) { // On fait defiler plusieurs nombre pour le suspens
afficher(chercher());
delay(200);
toutEteindre();
}
afficher(chercher()); //On affiche le "vrai" chiffre.
delay(3000);
toutEteindre();

}
}

Le résultat final en vidéo et quelques photos de notre circuit imprimé final.

[[Fichier: 20200328_165241.mp4|thumb|center|200px]]

Binome2019-9

2020-03-30T07:07:21Z

Bblack : /* Projet Intermédiaire: Le dé électronique */

=Introduction=
Dans ce BE, l'objectif est de réaliser une clé usb avoir une ou plusieurs fonctionnalités originales. La première partie est donc de réflechir à différentes idées de fonctions à introduire sur cette clé.

----

=Partie Réflexion=

Le principal objectif est de tenter d'imbriquer des clés par le biais d'un hub.

Nous avons aussi plusieurs idées de fonctionnalités originales de la clé USB :

*un haut-parleur (bruitage lors du remplissage, de la connexion, etc)
*vumètre à LED
*Dévérouillage de la clé via un mot de passe, on scinde la clé en 2 parties, la première ayant un stockage minimal servant à la demande du mot de passe, l'autre utile pour le stockage et l'échange d'informations. (bip d'erreur en cas d'échec du mot de passe)
*ajouter de la mémoire via un SHIELD

=Composants=

*Le coeur qui va être un micro-contrôleur AVR plus exactement l'ATMega16u2.
*une mémoire faible capacité (64Mb) avec l'AT45DB641E-SHN2B-T ou une grande capacité mais plus difficile à souder (128Gb) avec l'MT29F128G8

TUSB4041I Four-Port USB 2.0 Hub

= Test ReX 15/03/2020 =
Après quelques soudures le programme suivant passe sur l'ATtiny84 :

#define MAX_LED 7
int leds[]={0,1,2,3,4,5,6};
void setup() {
int i;
for(i=0;i<MAX_LED;i++) pinMode(leds[i], OUTPUT);
}
void loop() {
int i;
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], HIGH);
delay(1000);
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], LOW);
delay(1000);
}

Démonstration de l'exécution : [[media:binome2019-9-test1.mp4]].

= Projet Intermédiaire: Le dé électronique=

Ce projet nous a permis de prendre en main le logiciel Fritzing et Arduino IDE.

Tout d'abord nous avons élaboré les plans de notre dé en vue schématique, ce qui nous permet d'y voir plus clair et de mieux comprendre notre carte.
Après avoir effectué notre schématique (schéma1), celui-ci est indispensable car des que l'on se retrouve avec beaucoup de composant, on s'y perd facilement, l'erreur est donc plus facilement detectable et il est conseiller d'utiliser des label pour facilité la comprehension.
Le schéma finit, il faut maintenant agencer les composants de sorte qu'aucunes pistes ne se croisent sur notre circuit imprimé (schéma 2).

Voici une photo de la vue schématique et du circuit imprimé

[[Fichier:schéma 1.png|thumb|center|200px]]
[[Fichier:schéma 2.png|thumb|center|200px]]

Par la suite nos avons soudé sur notre circuit les 7 leds et 7 résistances, un travail très minutieux et assez compliqué.

Il ne reste plus qu'a coder notre microcontroleur, pour ce faire on utilise l'Arduino IDE

Le voici:

//========FONCTIONS PERSONALISEES - Il s'agit de fonctions créées sur mesure pour nos besoins

void toutEteindre() { //Cette fonction permet d'éteindre toutes les leds. Elle est de type "void" car elle ne revoit aucune valeur: elle se content d'exécuter les instructions.
digitalWrite(0, LOW); //Eteindre la led 1
digitalWrite(1, LOW); //Eteindre la led 2
digitalWrite(2, LOW); //Eteindre la led 3
digitalWrite(3, LOW); //Eteindre la led 4
digitalWrite(4, LOW); //Eteindre la led 5
digitalWrite(5, LOW); //Eteindre la led 6
digitalWrite(6, LOW); //Eteindre la led 7
}

void afficher(int nb) { //Cette fonction permet d'allumer les bonnes leds en fonction du nombre choisi.
//Elle prend en paramètre le nombre que l'on veut afficher.
switch (nb) { //C'est pareil qu'un if sauf que le if prend que des valeurs booléennes
case 1:
digitalWrite(4, HIGH);
break;
case 2:
digitalWrite(1, HIGH);
digitalWrite(6, HIGH);
break;
case 3:
digitalWrite(0, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
break;
case 4:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
break;
case 5:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
digitalWrite(4, HIGH);
break;
case 6:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
break;
}
}

int chercher() {
return random(1, 7);
}

//=================================================

void setup() {
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9,INPUT_PULLUP);
}

void loop() {
if (digitalRead(9) == LOW) {

for (int i = 1; i <= random(8, 15); i++) { // On fait defiler plusieurs nombre pour le suspens
afficher(chercher());
delay(200);
toutEteindre();
}
afficher(chercher()); //On affiche le "vrai" chiffre.
delay(3000);
toutEteindre();

}
}

Le résultat final en vidéo et quelques photos de notre circuit imprimé final.

Binome2019-9

2020-03-30T06:58:16Z

Bblack : /* Projet Intermédiaire: Le dé électronique */

=Introduction=
Dans ce BE, l'objectif est de réaliser une clé usb avoir une ou plusieurs fonctionnalités originales. La première partie est donc de réflechir à différentes idées de fonctions à introduire sur cette clé.

----

=Partie Réflexion=

Le principal objectif est de tenter d'imbriquer des clés par le biais d'un hub.

Nous avons aussi plusieurs idées de fonctionnalités originales de la clé USB :

*un haut-parleur (bruitage lors du remplissage, de la connexion, etc)
*vumètre à LED
*Dévérouillage de la clé via un mot de passe, on scinde la clé en 2 parties, la première ayant un stockage minimal servant à la demande du mot de passe, l'autre utile pour le stockage et l'échange d'informations. (bip d'erreur en cas d'échec du mot de passe)
*ajouter de la mémoire via un SHIELD

=Composants=

*Le coeur qui va être un micro-contrôleur AVR plus exactement l'ATMega16u2.
*une mémoire faible capacité (64Mb) avec l'AT45DB641E-SHN2B-T ou une grande capacité mais plus difficile à souder (128Gb) avec l'MT29F128G8

TUSB4041I Four-Port USB 2.0 Hub

= Test ReX 15/03/2020 =
Après quelques soudures le programme suivant passe sur l'ATtiny84 :

#define MAX_LED 7
int leds[]={0,1,2,3,4,5,6};
void setup() {
int i;
for(i=0;i<MAX_LED;i++) pinMode(leds[i], OUTPUT);
}
void loop() {
int i;
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], HIGH);
delay(1000);
for(i=0;i<MAX_LED;i++) digitalWrite(leds[i], LOW);
delay(1000);
}

Démonstration de l'exécution : [[media:binome2019-9-test1.mp4]].

= Projet Intermédiaire: Le dé électronique=

Ce projet nous a permis de prendre en main le logiciel Fritzing et Arduino IDE.

Tout d'abord nous avons élaboré les plans de notre dé en vue schématique, ce qui nous permet d'y voir plus clair sur notre PCB. Il fallait agencer les composants de sorte qu'aucunes pistes ne se croisent.

Voici une photo de la vue schématique:

[[Fichier:schéma 1.png|thumb|center|200px]]
[[Fichier:schéma 2.png|thumb|center|200px]]

Par la suite nos avons soudé sur notre circuit les 7 leds et 7 résistances, un travail très minutieux et assez compliqué.

Il ne reste plus qu'a coder notre microcontroleur, pour ce faire on utilise l'Arduino IDE

Le voici:

//========FONCTIONS PERSONALISEES - Il s'agit de fonctions créées sur mesure pour nos besoins

void toutEteindre() { //Cette fonction permet d'éteindre toutes les leds. Elle est de type "void" car elle ne revoit aucune valeur: elle se content d'exécuter les instructions.
digitalWrite(0, LOW); //Eteindre la led 1
digitalWrite(1, LOW); //Eteindre la led 2
digitalWrite(2, LOW); //Eteindre la led 3
digitalWrite(3, LOW); //Eteindre la led 4
digitalWrite(4, LOW); //Eteindre la led 5
digitalWrite(5, LOW); //Eteindre la led 6
digitalWrite(6, LOW); //Eteindre la led 7
}

void afficher(int nb) { //Cette fonction permet d'allumer les bonnes leds en fonction du nombre choisi.
//Elle prend en paramètre le nombre que l'on veut afficher.
switch (nb) { //C'est pareil qu'un if sauf que le if prend que des valeurs booléennes
case 1:
digitalWrite(4, HIGH);
break;
case 2:
digitalWrite(1, HIGH);
digitalWrite(6, HIGH);
break;
case 3:
digitalWrite(0, HIGH);
digitalWrite(3, HIGH);
digitalWrite(4, HIGH);
break;
case 4:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
break;
case 5:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(3, HIGH);
digitalWrite(6, HIGH);
digitalWrite(4, HIGH);
break;
case 6:
digitalWrite(0, HIGH);
digitalWrite(1, HIGH);
digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
break;
}
}

int chercher() {
return random(1, 7);
}

//=================================================

void setup() {
pinMode(0, OUTPUT);
pinMode(1, OUTPUT);
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9,INPUT_PULLUP);
}

void loop() {
if (digitalRead(9) == LOW) {

for (int i = 1; i <= random(8, 15); i++) { // On fait defiler plusieurs nombre pour le suspens
afficher(chercher());
delay(200);
toutEteindre();
}
afficher(chercher()); //On affiche le "vrai" chiffre.
delay(3000);
toutEteindre();

}
}