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

Binome2019-9

2020-05-21T16:19:44Z

Aroussel :

=<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.

--description du fonctionnement à faire--

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 :

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 ( je n'arrive pas à importer les composants de la parties mémoire ): [[Fichier:Cle usb black roussel.zip]]

Binome2019-9

2020-05-21T16:17:26Z

Aroussel :

=<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.

--description du fonctionnement à faire--

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 et 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 :

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 ( je n'arrive pas à importer les composants de la parties mémoire ): [[Fichier:Cle usb black roussel.zip]]

Binome2019-9

2020-05-21T16:14:58Z

Aroussel :

=<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.

--description du fonctionnement à faire--

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 et 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 :

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

void setup()
{
//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 ( je n'arrive pas à importer les composants de la parties mémoire ): [[Fichier:Cle usb black roussel.zip]]

Binome2019-9

2020-05-21T16:13:38Z

Aroussel :

=<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.

--description du fonctionnement à faire--

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 et 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 :

//constantes pour les broches de commande du 74HC595

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

void setup()
{
//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 ( je n'arrive pas à importer les composants de la parties mémoire ): [[Fichier:Cle usb black roussel.zip]]

Binome2019-9

2020-05-21T16:11:49Z

Aroussel :

=<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.

--description du fonctionnement à faire--

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 et 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 :

//constantes pour les broches de commande du 74HC595
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
// pour se programme j'ai fait le choix du tableau car cela reste simple pour un tutoriel

void setup()
{
//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 ( je n'arrive pas à importer les composants de la parties mémoire ): [[Fichier:Cle usb black roussel.zip]]

Binome2019-9

2020-05-21T16:10:00Z

Aroussel :

=<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.

--description du fonctionnement à faire--

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 et 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 :

//constantes pour les broches de commande du 74HC595
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
// pour se programme j'ai fait le choix du tableau car cela reste simple pour un tutoriel

void setup()
{
//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 ( je n'arrive pas à importer les composants de la parties mémoire ): [[Fichier:Cle usb black roussel.zip]]

Binome2019-9

2020-05-04T08:13:43Z

Aroussel :

=<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.

--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-03-26T17:31:22Z

Aroussel : /* 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]]
[[Fichier:schéma 2.png]]

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

Binome2019-9

2020-03-26T17:30:27Z

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

Binome2019-9

2020-03-26T17:27:35Z

Aroussel : /* Séance du 10/02/2020 : organisation du wiki et recherche composants */

=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|200px|thumb|rignt|schéma microcontroleur]]
[[Fichier:schéma 2.png|200px|thumb|rignt|schema leds]]

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

Nous avons choisi d'opter pour la clé USB déjà testée par les encadrants.
Nous avons cherché un capteur thermique "de surface" pour pouvoir le souder plus facilement sur notre clé. Voici à quoi il ressemble :

MCP9808T-E/MC arduino [https://fr.farnell.com/microchip/mcp9804-e-ms/capteur-de-temperature-i2c-2-7v/dp/1825061/ Lien pour retrouver le capteur thermique]

Binome2019-9

2020-03-26T17:26:20Z

Aroussel : /* 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|200px|thumb|rignt|schéma microcontroleur]]
[[Fichier:schéma 2.png|200px|thumb|rignt|schema leds]]

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

== <div class="mcwiki-header" style="border-radius: 15px; padding: 15px; font-weight: bold; text-align: center; font-size: 80%; background: #C2E5FF; vertical-align: top; width: 98%;"> '''Séance du 10/02/2020 : organisation du wiki et recherche composants''' </div> ==

Nous avons choisi d'opter pour la clé USB déjà testée par les encadrants.
Nous avons cherché un capteur thermique "de surface" pour pouvoir le souder plus facilement sur notre clé. Voici à quoi il ressemble :
[[Fichier:Capteure.png]]

MCP9808T-E/MC arduino [https://fr.farnell.com/microchip/mcp9804-e-ms/capteur-de-temperature-i2c-2-7v/dp/1825061/ Lien pour retrouver le capteur thermique]

Binome2019-9

2020-02-10T09:40:57Z

Aroussel : /* Composants */

==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

Binome2019-9

2020-02-10T09:22:56Z

Aroussel : /* Composants */

Binome2019-9

2020-02-10T09:21:41Z

Aroussel : /* Composants */

Binome2019-9

2020-02-10T09:21:09Z

Aroussel : /* Composants */

Binome2019-9

2020-02-10T09:18:05Z

Aroussel : /* Composants */

Binome2019-9

2020-02-10T09:16:42Z

Aroussel :

Binome2019-9

2020-02-10T09:15:37Z

Aroussel :

Binome2019-9

2020-02-10T08:46:59Z

Aroussel : /* Partie Réflexion */

==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

BE 2019-2020

2020-02-10T08:44:12Z

Aroussel : /* Réalisations des binômes */

= Présentation du bureau d'étude =

Nous vous proposons de découvrir ce qu'est réellement cet objet devenu banal appelé clé USB (Universal Serial Bus).

[[File:Firefly-serenity-usb-flash-drive.jpg|thumb|center|200px]]

Le bureau d'étude consiste à construire de A à Z une clé USB :
* en créant un circuit électronique ou PCB (Printed Circuit Board) à l’aide d’un logiciel ;
* en soudant des composants électroniques (micro-contrôleur, mémoire FLASH, ...) ;
* en programmant le micro-contrôleur pour gérer la communication USB en utilisant la bibliothèque LUFA (Lightweight USB Framework for AVRs) ;
* en programmant le micro-contrôleur pour accéder à la mémoire ;
* en fabriquant un beau boitier pour votre clef.

Pour personnaliser votre clé n'hésitez pas à ajouter des fonctionnalités :
* LED qui clignotent lors des accès en lecture ou écriture ;
* vumètre qui indique le remplissage de la clé ;
* micro-interrupteurs pour verrouiller la clé ;
* vibreur parce que c'est possible, vous trouverez bien une justification ;
* microphone permettant d’espionner les conversations ;
* toute autre fonction plus ou moins utile mais qui vous inspire ...

Les supports de la présentation de ce bureau d'études : [[Media:BE_clef_USB.pdf]].

= Survol d'USB =

== Evolution des connexions USB ==

L'acronyme USB signifie "Universal Serial Bus" et effectivement l'USB peut être défini comme un bus USB très verbeux. L'USB est géré par un consortium autonome "USB Implementers Forum".

[[File:USB-2.png|thumb|left|300px]] Jusqu'à la version 2, l'acronyme est fidèle à la réalité. Pour ces périphériques, 3 vitesses de transfert sont possibles sur la paire différentielle :
* basse vitesse : 1,5 Mb/s ;
* pleine vitesse : 12 Mb/s ;
* haute vitesse : 480 Mb/s.
<br style="clear: both;"/>
[[File:USB-3.jpg|thumb|right|300px]] A partir de l'USB 3.0, la notion de bus série est un peu oubliée. La vitesse augmente en utilisant les deux nouvelles paires blindées : 5Gb/s (super vitesse).
<br style="clear: both;"/>
[[File:USB-4.png|thumb|left|500px]] Et maintenant USB (USB 3.1, USB 3.2, USB 4) se prend pour de l'Ethernet. En effet, le connecteur USB-C ajoute, à la paire historique, quatre paires blindées. USB 3.2 promet des vitesses jusqu'à 20G/s.
<br style="clear: both;"/>

== Un protocole verbeux ==

[[File:USB-communication.gif|thumb|left|600px]]
L'initialisation d'un périphérique USB se fait comme suit :
* détection électrique de la connexion du périphérique ;
* alimentation électrique du périphérique ;
* utilisation de l'adresse temporaire 0 sur le bus ;
* récupération de la taille des messages pour le point d'accès 0 ;
* envoi de l'adresse au périphérique sur le point d'accès 0 ;
* envoi des descripteurs du périphérique au contrôleur USB via le point d'accès 0.
Pour un périphérique simple :
* souris : environ 100 octets pour le descripteur de configuration ;
* clavier : environ 150 octets pour le descripteur de configuration.
<br style="clear: both;"/>

[[File:USB-descripteurs.gif|thumb|right|700px]]
Les points d'accès (terminaison sur le schéma) :
* des identifiants sur 8 bits (numéro sur 4 bits) ;
* un point d'accès de contrôle de numéro 0 bidirectionnel ;
* les communications se font de ou vers les points d'accès ;
* un sens de communication (bit de poid fort) :
** IN => du périphérique vers le contrôleur ;
** OUT => du contrôleur vers le périphérique.
* la direction est IN ou OUT vis à vis de l’hôte.
Plusieurs types de points d'accès :
* isodromique (isochronous) : débit réservé (e.g. vidéo en temps réel) ;
* par interruption (interrupt) : latence garantie (e.g. souris) ;
* de volume (bulk) : débit maximal sans garantie (e.g. clef mémoire).
<br style="clear: both;"/>

= Logiciels =

Pour la conception de circuits imprimés nous vous recommandons le logiciel [http://fritzing.org/home/ fritzing].

Pour la découpe laser de nombreux utilisateurs utilisent [https://inkscape.org/fr/ inkscape].

Pour la conception 3D vous pouvez tenter [http://www.freecadweb.org/?lang=fr_FR freeCAD]. Une solution en ligne existe : [https://www.onshape.com/ onshape].

Pour la programmation du micro-contrôleur vous utiliserez le compilateur C <tt>avr-gcc</tt> et le logiciel de téléversement <tt>dfu-programmer</tt>.

= Les composants électroniques =

[[File:atmega16u2.png|thumb|left|200px|ATMega16u2]]
Le coeur de votre clé va être un micro-contrôleur AVR plus exactement l'ATMega16u2. Ce micro-contrôleur possède l'électronique nécessaire pour la gestion d'un bus USB 2.0.
<br style="clear: both;"/>

[[File:adesto64Mb.jpg|thumb|left|200px|AT45DB641E-SHN2B-T]]
[[File:MT29F128G08.jpg|thumb|right|200px|MT29F128G8]]
Sans mémoire une clé n'est pas une clé. Vous utiliserez des mémoires faciles à gérer avec un ATMega16u2. Ces mémoires sont accessibles par un bus série SPI et facile à souder. Par contre elles sont de faible capacité (64Mb). Si vous êtes téméraire, vous pouvez utiliser une mémoire accessible par un bus de 8 bits, plus difficile à souder, plus difficile à programmer mais d'une capacité intéressante (128Gb).
<br style="clear: both;"/>

Il vous faudra aussi quelques autres composants comme un quartz, des résistances, des condensateurs, des diodes, des régulateurs de tension et bien sur des LED pour ajouter un peu de lumière. La carte de base peut être décrite comme suit.
* Le micro-contrôleur peut être accompagné d'un quartz à 8Mhz et de ses condensateurs et résistance.
* Le micro-contrôleur peut être alimenté par le connecteur USB en 5v (broche UVCC) mais avec ses lignes VCC et AVCC bouclées sur la sortie UCAP du régulateur 3.3v interne.
* Un convertisseur 5v vers 3.3v est nécessaire pour l'alimentation des mémoires.
* Le micro-contrôleur dialogue avec les mémoires par le bus SPI, une ligne de sélection est nécessaire par mémoire.

Pour la conception de votre clé vous pouvez vous appuyer sur un prototype de clef réalisé pour ce bureau d'études.

[[File:cle_usb_schema.png|thumb|left|400px|Schéma électronique]]
[[File:clef_usb_pcb.png|thumb|right|400px|Carte électronique]]
<br style="clear: both;"/>
Le schéma décrit le circuit électronique partie par partie.
A partir du circuit, il faut créer une carte sans croisement de pistes pour éviter les court-circuits.
Le fichier source Fritzing est disponible : [[Media:cle_usb.zip]] (renommer en <tt>.fzz</tt>).

Une autre carte est disponible pour une mémoire parallèle de plus grande capacité. Attention cette carte n'a pas été testée.

[[File:cle_usb_bis_schema.png|thumb|left|400px|Schéma électronique]]
[[File:clef_usb_bis_pcb.png|thumb|right|400px|Carte électronique]]
<br style="clear: both;"/>
Le fichier source Fritzing est disponible : [[Media:cle_usb_bis.zip]] (renommer en <tt>.fzz</tt>).

= Test des cartes =

[[File:cle_usb_recto.jpg|thumb|left|400px|Recto des deux cartes]]
[[File:cle_usb_verso.jpg|thumb|right|400px|Verso des deux cartes]]
Vision recto et verso des deux circuits décrit dans la section précédente (ancienne version à gauche). A noter que dans l'ancienne version seule les deux puces mémoire se trouvent au recto. Pour la nouvelle version la carte a du être agrandie et le micro-contrôleur rejoint la mémoire au verso.
<br style="clear: both;"/>

La première étape de test consiste à insérer les PCB dans un port USB. Remarquez la sur-épaisseur réalisée à l'aide d'un papier un peu épais pour assurer le contact. Si l'ATMega16u2 est fonctionne correctement, en lançant l'utilitaire <tt>lsusb</tt> vous devez voir apparaître un périphérique labellé <tt>Atmel DFU device</tt>.

Pour tester plus en avant, il est proposé d'envoyer sur le micro-contrôleur un programme permettant de faire clignoter la LED connectée au micro-contrôleur (la LED est contrôlée par PB6 sur l'ancienne version et sur PB0 sur la nouvelle).

Vous pouvez trouver les programmes de test dans cette archive : [[Media:ClefUSB.zip]]. Pour compiler les programmes, il suffit de se placer dans le répertoire correspondant à la version de la clef et lancer le <tt>makefile</tt> avec la commande <tt>make</tt>. Pour télécharger le programme un simple <tt>make upload</tt> suffit. Pour remettre les micro-contrôleur en mode DFU pour les reprogrammer, il faut court-circuiter les broches <tt>reset</tt> et de la masse (connecteur à deux broches sur les deux cartes).

Voila le résultat de l'exécution du programme de test du micro-contrôleur sur la nouvelle version : [[Media:ClefUSBTestLed.mp4]].

Il faut maintenant souder le régulateur 3,3v pour alimenter les mémoires et aussi souder les-dites mémoires.

Ensuite il faut tester si l'accès aux mémoires fonctionne. Les programmes sont différents suivant les types de mémoire.

== Test des mémoires AT45DB641E ==

Pour tester un des deux mémoires, il faut déjà sélectionner la mémoire sur le bus SPI. La première mémoire se sélectionne en passant la ligne <tt>PD0</tt> à l'état bas. Pour la seconde mémoire, il faut utiliser la ligne <tt>PB5</tt>.

Pour tester la mémoire, il est possible de demander la valeur du registre d'état. Pour cela il faut envoyer l'octet <tt>0xD7</tt> sur le bus SPI, une fois la mémoire sélectionnée. Ensuite, il faut lire les deux octets du registre d'état puis remonter la ligne de sélection à l'état haut.

== Test de la mémoire MT29F128G8 ==

Cette mémoire est sélectionnée par défaut. Il faut juste arriver à lui envoyer un ordre en utilisant les 8 lignes de contrôle.

= Bibliothèque LUFA =

Pour la gestion du bus USB par le micro-contrôleur nous allons nous appuyer au maximum sur la bibliothèque USB LUFA. Cette bibliothèque permet d'exploiter plus facilement les aspects USB des micro-contrôleurs AVR comme l'ATMega16u2.

Vous pouvez télécharger la dernière version de la bibliothèque [http://www.fourwalledcubicle.com/LUFA.php]. Il est ensuite conseillé d'effectuer quelques manipulations pour pouvoir développer dans de bonnes conditions.
* Créez un répertoire <tt>PolytechLille</tt> au même niveau que les répertoires <tt>Demos</tt> et <tt>Projects</tt>.
* Dans ce répertoire copiez la démonstration de périphérique USB bas niveau <tt>MassStorage</tt>. Au niveau du <tt>makefile</tt> indiquez <tt>atmega16u2</tt> comme micro-contrôleur, <tt>UNO</tt> comme platine et restez à 8Mhz.
* Il faut ensuite modifier la configuration de la mémoire et les fonctions d'accès à cette mémoire dans le sous-répertoire <tt>Lib</tt> du répertoire <tt>PolytechLille/MassStorage</tt>.

Pour téléverser votre programme sur l’<tt>ATMega16u2</tt>, le paquetage Debian <tt>dfu-programmer</tt> est nécessaire. Installez-le au besoin. La procédure à suivre pour charger votre programme sur l’<tt>ATMega16u2</tt> est la suivante :

* court-circuitez momentanément les lignes reset et masse de l’<tt>ATMega16u2</tt>, l'utilitaire <tt>lsusb</tt> doit lister la carte comme étant en mode DFU, vous pouvez alors exécuter les commandes suivantes :
** <tt>dfu-programmer atmega16u2 erase</tt>
** <tt>dfu-programmer atmega16u2 flash MassStorage.hex</tt>
** <tt>dfu-programmer atmega16u2 reset</tt>
* débranchez et rebranchez votre carte, votre programme doit être actif sur le micro-contrôleur.

= Réalisations des binômes =

{| class="wikitable"
! Numéro !! Elèves !! Fonctionnalité supplémentaire !! Page
|-
| Binôme 1
| Nicolas DEBAISIEUX & Maxence FLAMENT
| Affichage température par leds
| [[Binome2019-1|Binôme 1 2019/2020]]
|-
| Binôme 2
| Eve POITEVIN & Alix DUFOUR
| Déverrouillage par haut volume sonore
| [[Binome2019-2|Binôme 2 2019/2020]]
|-
| Binôme 3
| Corentin GIELIN & Julien DUMON
| Afficheurs 7-seg en tant que vumètre numérique
| [[Binome2019-3|Binôme 3 2019/2020]]
|-
| Binôme 4
| Clément DELECOURT & Thomas MOSTOWFI
| Signal mauvaise orientation
| [[Binome2019-4|Binôme 4 2019/2020]]
|-
| Binôme 5
| Gaëtan DELPLANQUE & Tristan PAYEN
| Verrouillage code
| [[Binome2019-5|Binôme 5 2019/2020]]
|-
| Binôme 6
| Louise MAES & Léo POUMAER
| Ecran LCD + vumètre + affichage nom fichier
| [[Binome2019-6|Binôme 6 2019/2020]]
|-
| Binôme 7
| Martin SERGEANT & Quirin DECAUDIN
|
| [[Binome2019-7|Binôme 7 2019/2020]]
|-
| Binôme 8
| Mateo POURRIER & Martin PLAUD
|
| [[Binome2019-8|Binôme 8 2019/2020]]
|-
| Binôme 9
| Baptiste BLACK & Alexandre ROUSSEL
| Hub + Vumètre
| [[Binome2019-9|Binôme 9 2019/2020]]
|-
| Binôme 10
| Theo DELAUNOIS & Antoine MALENGE
|
| [[Binome2019-10|Binôme 10 2019/2020]]
|-
| Binôme 11
| Florian DERLIQUE & Ahimen BENDIF
|
| [[Binome2019-11|Binôme 11 2019/2020]]
|-
|}

BE 2019-2020

2020-02-10T08:43:57Z

Aroussel : /* Réalisations des binômes */

= Présentation du bureau d'étude =

Nous vous proposons de découvrir ce qu'est réellement cet objet devenu banal appelé clé USB (Universal Serial Bus).

[[File:Firefly-serenity-usb-flash-drive.jpg|thumb|center|200px]]

Le bureau d'étude consiste à construire de A à Z une clé USB :
* en créant un circuit électronique ou PCB (Printed Circuit Board) à l’aide d’un logiciel ;
* en soudant des composants électroniques (micro-contrôleur, mémoire FLASH, ...) ;
* en programmant le micro-contrôleur pour gérer la communication USB en utilisant la bibliothèque LUFA (Lightweight USB Framework for AVRs) ;
* en programmant le micro-contrôleur pour accéder à la mémoire ;
* en fabriquant un beau boitier pour votre clef.

Pour personnaliser votre clé n'hésitez pas à ajouter des fonctionnalités :
* LED qui clignotent lors des accès en lecture ou écriture ;
* vumètre qui indique le remplissage de la clé ;
* micro-interrupteurs pour verrouiller la clé ;
* vibreur parce que c'est possible, vous trouverez bien une justification ;
* microphone permettant d’espionner les conversations ;
* toute autre fonction plus ou moins utile mais qui vous inspire ...

Les supports de la présentation de ce bureau d'études : [[Media:BE_clef_USB.pdf]].

= Survol d'USB =

== Evolution des connexions USB ==

L'acronyme USB signifie "Universal Serial Bus" et effectivement l'USB peut être défini comme un bus USB très verbeux. L'USB est géré par un consortium autonome "USB Implementers Forum".

[[File:USB-2.png|thumb|left|300px]] Jusqu'à la version 2, l'acronyme est fidèle à la réalité. Pour ces périphériques, 3 vitesses de transfert sont possibles sur la paire différentielle :
* basse vitesse : 1,5 Mb/s ;
* pleine vitesse : 12 Mb/s ;
* haute vitesse : 480 Mb/s.
<br style="clear: both;"/>
[[File:USB-3.jpg|thumb|right|300px]] A partir de l'USB 3.0, la notion de bus série est un peu oubliée. La vitesse augmente en utilisant les deux nouvelles paires blindées : 5Gb/s (super vitesse).
<br style="clear: both;"/>
[[File:USB-4.png|thumb|left|500px]] Et maintenant USB (USB 3.1, USB 3.2, USB 4) se prend pour de l'Ethernet. En effet, le connecteur USB-C ajoute, à la paire historique, quatre paires blindées. USB 3.2 promet des vitesses jusqu'à 20G/s.
<br style="clear: both;"/>

== Un protocole verbeux ==

[[File:USB-communication.gif|thumb|left|600px]]
L'initialisation d'un périphérique USB se fait comme suit :
* détection électrique de la connexion du périphérique ;
* alimentation électrique du périphérique ;
* utilisation de l'adresse temporaire 0 sur le bus ;
* récupération de la taille des messages pour le point d'accès 0 ;
* envoi de l'adresse au périphérique sur le point d'accès 0 ;
* envoi des descripteurs du périphérique au contrôleur USB via le point d'accès 0.
Pour un périphérique simple :
* souris : environ 100 octets pour le descripteur de configuration ;
* clavier : environ 150 octets pour le descripteur de configuration.
<br style="clear: both;"/>

[[File:USB-descripteurs.gif|thumb|right|700px]]
Les points d'accès (terminaison sur le schéma) :
* des identifiants sur 8 bits (numéro sur 4 bits) ;
* un point d'accès de contrôle de numéro 0 bidirectionnel ;
* les communications se font de ou vers les points d'accès ;
* un sens de communication (bit de poid fort) :
** IN => du périphérique vers le contrôleur ;
** OUT => du contrôleur vers le périphérique.
* la direction est IN ou OUT vis à vis de l’hôte.
Plusieurs types de points d'accès :
* isodromique (isochronous) : débit réservé (e.g. vidéo en temps réel) ;
* par interruption (interrupt) : latence garantie (e.g. souris) ;
* de volume (bulk) : débit maximal sans garantie (e.g. clef mémoire).
<br style="clear: both;"/>

= Logiciels =

Pour la conception de circuits imprimés nous vous recommandons le logiciel [http://fritzing.org/home/ fritzing].

Pour la découpe laser de nombreux utilisateurs utilisent [https://inkscape.org/fr/ inkscape].

Pour la conception 3D vous pouvez tenter [http://www.freecadweb.org/?lang=fr_FR freeCAD]. Une solution en ligne existe : [https://www.onshape.com/ onshape].

Pour la programmation du micro-contrôleur vous utiliserez le compilateur C <tt>avr-gcc</tt> et le logiciel de téléversement <tt>dfu-programmer</tt>.

= Les composants électroniques =

[[File:atmega16u2.png|thumb|left|200px|ATMega16u2]]
Le coeur de votre clé va être un micro-contrôleur AVR plus exactement l'ATMega16u2. Ce micro-contrôleur possède l'électronique nécessaire pour la gestion d'un bus USB 2.0.
<br style="clear: both;"/>

[[File:adesto64Mb.jpg|thumb|left|200px|AT45DB641E-SHN2B-T]]
[[File:MT29F128G08.jpg|thumb|right|200px|MT29F128G8]]
Sans mémoire une clé n'est pas une clé. Vous utiliserez des mémoires faciles à gérer avec un ATMega16u2. Ces mémoires sont accessibles par un bus série SPI et facile à souder. Par contre elles sont de faible capacité (64Mb). Si vous êtes téméraire, vous pouvez utiliser une mémoire accessible par un bus de 8 bits, plus difficile à souder, plus difficile à programmer mais d'une capacité intéressante (128Gb).
<br style="clear: both;"/>

Il vous faudra aussi quelques autres composants comme un quartz, des résistances, des condensateurs, des diodes, des régulateurs de tension et bien sur des LED pour ajouter un peu de lumière. La carte de base peut être décrite comme suit.
* Le micro-contrôleur peut être accompagné d'un quartz à 8Mhz et de ses condensateurs et résistance.
* Le micro-contrôleur peut être alimenté par le connecteur USB en 5v (broche UVCC) mais avec ses lignes VCC et AVCC bouclées sur la sortie UCAP du régulateur 3.3v interne.
* Un convertisseur 5v vers 3.3v est nécessaire pour l'alimentation des mémoires.
* Le micro-contrôleur dialogue avec les mémoires par le bus SPI, une ligne de sélection est nécessaire par mémoire.

Pour la conception de votre clé vous pouvez vous appuyer sur un prototype de clef réalisé pour ce bureau d'études.

[[File:cle_usb_schema.png|thumb|left|400px|Schéma électronique]]
[[File:clef_usb_pcb.png|thumb|right|400px|Carte électronique]]
<br style="clear: both;"/>
Le schéma décrit le circuit électronique partie par partie.
A partir du circuit, il faut créer une carte sans croisement de pistes pour éviter les court-circuits.
Le fichier source Fritzing est disponible : [[Media:cle_usb.zip]] (renommer en <tt>.fzz</tt>).

Une autre carte est disponible pour une mémoire parallèle de plus grande capacité. Attention cette carte n'a pas été testée.

[[File:cle_usb_bis_schema.png|thumb|left|400px|Schéma électronique]]
[[File:clef_usb_bis_pcb.png|thumb|right|400px|Carte électronique]]
<br style="clear: both;"/>
Le fichier source Fritzing est disponible : [[Media:cle_usb_bis.zip]] (renommer en <tt>.fzz</tt>).

= Test des cartes =

[[File:cle_usb_recto.jpg|thumb|left|400px|Recto des deux cartes]]
[[File:cle_usb_verso.jpg|thumb|right|400px|Verso des deux cartes]]
Vision recto et verso des deux circuits décrit dans la section précédente (ancienne version à gauche). A noter que dans l'ancienne version seule les deux puces mémoire se trouvent au recto. Pour la nouvelle version la carte a du être agrandie et le micro-contrôleur rejoint la mémoire au verso.
<br style="clear: both;"/>

La première étape de test consiste à insérer les PCB dans un port USB. Remarquez la sur-épaisseur réalisée à l'aide d'un papier un peu épais pour assurer le contact. Si l'ATMega16u2 est fonctionne correctement, en lançant l'utilitaire <tt>lsusb</tt> vous devez voir apparaître un périphérique labellé <tt>Atmel DFU device</tt>.

Pour tester plus en avant, il est proposé d'envoyer sur le micro-contrôleur un programme permettant de faire clignoter la LED connectée au micro-contrôleur (la LED est contrôlée par PB6 sur l'ancienne version et sur PB0 sur la nouvelle).

Vous pouvez trouver les programmes de test dans cette archive : [[Media:ClefUSB.zip]]. Pour compiler les programmes, il suffit de se placer dans le répertoire correspondant à la version de la clef et lancer le <tt>makefile</tt> avec la commande <tt>make</tt>. Pour télécharger le programme un simple <tt>make upload</tt> suffit. Pour remettre les micro-contrôleur en mode DFU pour les reprogrammer, il faut court-circuiter les broches <tt>reset</tt> et de la masse (connecteur à deux broches sur les deux cartes).

Voila le résultat de l'exécution du programme de test du micro-contrôleur sur la nouvelle version : [[Media:ClefUSBTestLed.mp4]].

Il faut maintenant souder le régulateur 3,3v pour alimenter les mémoires et aussi souder les-dites mémoires.

Ensuite il faut tester si l'accès aux mémoires fonctionne. Les programmes sont différents suivant les types de mémoire.

== Test des mémoires AT45DB641E ==

Pour tester un des deux mémoires, il faut déjà sélectionner la mémoire sur le bus SPI. La première mémoire se sélectionne en passant la ligne <tt>PD0</tt> à l'état bas. Pour la seconde mémoire, il faut utiliser la ligne <tt>PB5</tt>.

Pour tester la mémoire, il est possible de demander la valeur du registre d'état. Pour cela il faut envoyer l'octet <tt>0xD7</tt> sur le bus SPI, une fois la mémoire sélectionnée. Ensuite, il faut lire les deux octets du registre d'état puis remonter la ligne de sélection à l'état haut.

== Test de la mémoire MT29F128G8 ==

Cette mémoire est sélectionnée par défaut. Il faut juste arriver à lui envoyer un ordre en utilisant les 8 lignes de contrôle.

= Bibliothèque LUFA =

Pour la gestion du bus USB par le micro-contrôleur nous allons nous appuyer au maximum sur la bibliothèque USB LUFA. Cette bibliothèque permet d'exploiter plus facilement les aspects USB des micro-contrôleurs AVR comme l'ATMega16u2.

Vous pouvez télécharger la dernière version de la bibliothèque [http://www.fourwalledcubicle.com/LUFA.php]. Il est ensuite conseillé d'effectuer quelques manipulations pour pouvoir développer dans de bonnes conditions.
* Créez un répertoire <tt>PolytechLille</tt> au même niveau que les répertoires <tt>Demos</tt> et <tt>Projects</tt>.
* Dans ce répertoire copiez la démonstration de périphérique USB bas niveau <tt>MassStorage</tt>. Au niveau du <tt>makefile</tt> indiquez <tt>atmega16u2</tt> comme micro-contrôleur, <tt>UNO</tt> comme platine et restez à 8Mhz.
* Il faut ensuite modifier la configuration de la mémoire et les fonctions d'accès à cette mémoire dans le sous-répertoire <tt>Lib</tt> du répertoire <tt>PolytechLille/MassStorage</tt>.

Pour téléverser votre programme sur l’<tt>ATMega16u2</tt>, le paquetage Debian <tt>dfu-programmer</tt> est nécessaire. Installez-le au besoin. La procédure à suivre pour charger votre programme sur l’<tt>ATMega16u2</tt> est la suivante :

* court-circuitez momentanément les lignes reset et masse de l’<tt>ATMega16u2</tt>, l'utilitaire <tt>lsusb</tt> doit lister la carte comme étant en mode DFU, vous pouvez alors exécuter les commandes suivantes :
** <tt>dfu-programmer atmega16u2 erase</tt>
** <tt>dfu-programmer atmega16u2 flash MassStorage.hex</tt>
** <tt>dfu-programmer atmega16u2 reset</tt>
* débranchez et rebranchez votre carte, votre programme doit être actif sur le micro-contrôleur.

= Réalisations des binômes =

{| class="wikitable"
! Numéro !! Elèves !! Fonctionnalité supplémentaire !! Page
|-
| Binôme 1
| Nicolas DEBAISIEUX & Maxence FLAMENT
| Affichage température par leds
| [[Binome2019-1|Binôme 1 2019/2020]]
|-
| Binôme 2
| Eve POITEVIN & Alix DUFOUR
| Déverrouillage par haut volume sonore
| [[Binome2019-2|Binôme 2 2019/2020]]
|-
| Binôme 3
| Corentin GIELIN & Julien DUMON
| Afficheurs 7-seg en tant que vumètre numérique
| [[Binome2019-3|Binôme 3 2019/2020]]
|-
| Binôme 4
| Clément DELECOURT & Thomas MOSTOWFI
| Signal mauvaise orientation
| [[Binome2019-4|Binôme 4 2019/2020]]
|-
| Binôme 5
| Gaëtan DELPLANQUE & Tristan PAYEN
| Verrouillage code
| [[Binome2019-5|Binôme 5 2019/2020]]
|-
| Binôme 6
| Louise MAES & Léo POUMAER
| Ecran LCD + vumètre + affichage nom fichier
| [[Binome2019-6|Binôme 6 2019/2020]]
|-
| Binôme 7
| Martin SERGEANT & Quirin DECAUDIN
|
| [[Binome2019-7|Binôme 7 2019/2020]]
|-
| Binôme 8
| Mateo POURRIER & Martin PLAUD
|
| [[Binome2019-8|Binôme 8 2019/2020]]
|-
| Binôme 9
| Baptiste BLACK & Alexandre ROUSSEL
| Hub+Vumètre
| [[Binome2019-9|Binôme 9 2019/2020]]
|-
| Binôme 10
| Theo DELAUNOIS & Antoine MALENGE
|
| [[Binome2019-10|Binôme 10 2019/2020]]
|-
| Binôme 11
| Florian DERLIQUE & Ahimen BENDIF
|
| [[Binome2019-11|Binôme 11 2019/2020]]
|-
|}

BE 2019-2020

2020-02-10T08:29:40Z

Aroussel : /* Réalisations des binômes */

= Présentation du bureau d'étude =

Nous vous proposons de découvrir ce qu'est réellement cet objet devenu banal appelé clé USB (Universal Serial Bus).

[[File:Firefly-serenity-usb-flash-drive.jpg|thumb|center|200px]]

Le bureau d'étude consiste à construire de A à Z une clé USB :
* en créant un circuit électronique ou PCB (Printed Circuit Board) à l’aide d’un logiciel ;
* en soudant des composants électroniques (micro-contrôleur, mémoire FLASH, ...) ;
* en programmant le micro-contrôleur pour gérer la communication USB en utilisant la bibliothèque LUFA (Lightweight USB Framework for AVRs) ;
* en programmant le micro-contrôleur pour accéder à la mémoire ;
* en fabriquant un beau boitier pour votre clef.

Pour personnaliser votre clé n'hésitez pas à ajouter des fonctionnalités :
* LED qui clignotent lors des accès en lecture ou écriture ;
* vumètre qui indique le remplissage de la clé ;
* micro-interrupteurs pour verrouiller la clé ;
* vibreur parce que c'est possible, vous trouverez bien une justification ;
* microphone permettant d’espionner les conversations ;
* toute autre fonction plus ou moins utile mais qui vous inspire ...

Les supports de la présentation de ce bureau d'études : [[Media:BE_clef_USB.pdf]].

= Survol d'USB =

== Evolution des connexions USB ==

L'acronyme USB signifie "Universal Serial Bus" et effectivement l'USB peut être défini comme un bus USB très verbeux. L'USB est géré par un consortium autonome "USB Implementers Forum".

[[File:USB-2.png|thumb|left|300px]] Jusqu'à la version 2, l'acronyme est fidèle à la réalité. Pour ces périphériques, 3 vitesses de transfert sont possibles sur la paire différentielle :
* basse vitesse : 1,5 Mb/s ;
* pleine vitesse : 12 Mb/s ;
* haute vitesse : 480 Mb/s.
<br style="clear: both;"/>
[[File:USB-3.jpg|thumb|right|300px]] A partir de l'USB 3.0, la notion de bus série est un peu oubliée. La vitesse augmente en utilisant les deux nouvelles paires blindées : 5Gb/s (super vitesse).
<br style="clear: both;"/>
[[File:USB-4.png|thumb|left|500px]] Et maintenant USB (USB 3.1, USB 3.2, USB 4) se prend pour de l'Ethernet. En effet, le connecteur USB-C ajoute, à la paire historique, quatre paires blindées. USB 3.2 promet des vitesses jusqu'à 20G/s.
<br style="clear: both;"/>

== Un protocole verbeux ==

[[File:USB-communication.gif|thumb|left|600px]]
L'initialisation d'un périphérique USB se fait comme suit :
* détection électrique de la connexion du périphérique ;
* alimentation électrique du périphérique ;
* utilisation de l'adresse temporaire 0 sur le bus ;
* récupération de la taille des messages pour le point d'accès 0 ;
* envoi de l'adresse au périphérique sur le point d'accès 0 ;
* envoi des descripteurs du périphérique au contrôleur USB via le point d'accès 0.
Pour un périphérique simple :
* souris : environ 100 octets pour le descripteur de configuration ;
* clavier : environ 150 octets pour le descripteur de configuration.
<br style="clear: both;"/>

[[File:USB-descripteurs.gif|thumb|right|700px]]
Les points d'accès (terminaison sur le schéma) :
* des identifiants sur 8 bits (numéro sur 4 bits) ;
* un point d'accès de contrôle de numéro 0 bidirectionnel ;
* les communications se font de ou vers les points d'accès ;
* un sens de communication (bit de poid fort) :
** IN => du périphérique vers le contrôleur ;
** OUT => du contrôleur vers le périphérique.
* la direction est IN ou OUT vis à vis de l’hôte.
Plusieurs types de points d'accès :
* isodromique (isochronous) : débit réservé (e.g. vidéo en temps réel) ;
* par interruption (interrupt) : latence garantie (e.g. souris) ;
* de volume (bulk) : débit maximal sans garantie (e.g. clef mémoire).
<br style="clear: both;"/>

= Logiciels =

Pour la conception de circuits imprimés nous vous recommandons le logiciel [http://fritzing.org/home/ fritzing].

Pour la découpe laser de nombreux utilisateurs utilisent [https://inkscape.org/fr/ inkscape].

Pour la conception 3D vous pouvez tenter [http://www.freecadweb.org/?lang=fr_FR freeCAD]. Une solution en ligne existe : [https://www.onshape.com/ onshape].

Pour la programmation du micro-contrôleur vous utiliserez le compilateur C <tt>avr-gcc</tt> et le logiciel de téléversement <tt>dfu-programmer</tt>.

= Les composants électroniques =

[[File:atmega16u2.png|thumb|left|200px|ATMega16u2]]
Le coeur de votre clé va être un micro-contrôleur AVR plus exactement l'ATMega16u2. Ce micro-contrôleur possède l'électronique nécessaire pour la gestion d'un bus USB 2.0.
<br style="clear: both;"/>

[[File:adesto64Mb.jpg|thumb|left|200px|AT45DB641E-SHN2B-T]]
[[File:MT29F128G08.jpg|thumb|right|200px|MT29F128G8]]
Sans mémoire une clé n'est pas une clé. Vous utiliserez des mémoires faciles à gérer avec un ATMega16u2. Ces mémoires sont accessibles par un bus série SPI et facile à souder. Par contre elles sont de faible capacité (64Mb). Si vous êtes téméraire, vous pouvez utiliser une mémoire accessible par un bus de 8 bits, plus difficile à souder, plus difficile à programmer mais d'une capacité intéressante (128Gb).
<br style="clear: both;"/>

Il vous faudra aussi quelques autres composants comme un quartz, des résistances, des condensateurs, des diodes, des régulateurs de tension et bien sur des LED pour ajouter un peu de lumière. La carte de base peut être décrite comme suit.
* Le micro-contrôleur peut être accompagné d'un quartz à 8Mhz et de ses condensateurs et résistance.
* Le micro-contrôleur peut être alimenté par le connecteur USB en 5v (broche UVCC) mais avec ses lignes VCC et AVCC bouclées sur la sortie UCAP du régulateur 3.3v interne.
* Un convertisseur 5v vers 3.3v est nécessaire pour l'alimentation des mémoires.
* Le micro-contrôleur dialogue avec les mémoires par le bus SPI, une ligne de sélection est nécessaire par mémoire.

Pour la conception de votre clé vous pouvez vous appuyer sur un prototype de clef réalisé pour ce bureau d'études.

[[File:cle_usb_schema.png|thumb|left|400px|Schéma électronique]]
[[File:clef_usb_pcb.png|thumb|right|400px|Carte électronique]]
<br style="clear: both;"/>
Le schéma décrit le circuit électronique partie par partie.
A partir du circuit, il faut créer une carte sans croisement de pistes pour éviter les court-circuits.
Le fichier source Fritzing est disponible : [[Media:cle_usb.zip]] (renommer en <tt>.fzz</tt>).

Une autre carte est disponible pour une mémoire parallèle de plus grande capacité. Attention cette carte n'a pas été testée.

[[File:cle_usb_bis_schema.png|thumb|left|400px|Schéma électronique]]
[[File:clef_usb_bis_pcb.png|thumb|right|400px|Carte électronique]]
<br style="clear: both;"/>
Le fichier source Fritzing est disponible : [[Media:cle_usb_bis.zip]] (renommer en <tt>.fzz</tt>).

= Test des cartes =

[[File:cle_usb_recto.jpg|thumb|left|400px|Recto des deux cartes]]
[[File:cle_usb_verso.jpg|thumb|right|400px|Verso des deux cartes]]
Vision recto et verso des deux circuits décrit dans la section précédente (ancienne version à gauche). A noter que dans l'ancienne version seule les deux puces mémoire se trouvent au recto. Pour la nouvelle version la carte a du être agrandie et le micro-contrôleur rejoint la mémoire au verso.
<br style="clear: both;"/>

La première étape de test consiste à insérer les PCB dans un port USB. Remarquez la sur-épaisseur réalisée à l'aide d'un papier un peu épais pour assurer le contact. Si l'ATMega16u2 est fonctionne correctement, en lançant l'utilitaire <tt>lsusb</tt> vous devez voir apparaître un périphérique labellé <tt>Atmel DFU device</tt>.

Pour tester plus en avant, il est proposé d'envoyer sur le micro-contrôleur un programme permettant de faire clignoter la LED connectée au micro-contrôleur (la LED est contrôlée par PB6 sur l'ancienne version et sur PB0 sur la nouvelle).

Vous pouvez trouver les programmes de test dans cette archive : [[Media:ClefUSB.zip]]. Pour compiler les programmes, il suffit de se placer dans le répertoire correspondant à la version de la clef et lancer le <tt>makefile</tt> avec la commande <tt>make</tt>. Pour télécharger le programme un simple <tt>make upload</tt> suffit. Pour remettre les micro-contrôleur en mode DFU pour les reprogrammer, il faut court-circuiter les broches <tt>reset</tt> et de la masse (connecteur à deux broches sur les deux cartes).

Voila le résultat de l'exécution du programme de test du micro-contrôleur sur la nouvelle version : [[Media:ClefUSBTestLed.mp4]].

Il faut maintenant souder le régulateur 3,3v pour alimenter les mémoires et aussi souder les-dites mémoires.

Ensuite il faut tester si l'accès aux mémoires fonctionne. Les programmes sont différents suivant les types de mémoire.

== Test des mémoires AT45DB641E ==

Pour tester un des deux mémoires, il faut déjà sélectionner la mémoire sur le bus SPI. La première mémoire se sélectionne en passant la ligne <tt>PD0</tt> à l'état bas. Pour la seconde mémoire, il faut utiliser la ligne <tt>PB5</tt>.

Pour tester la mémoire, il est possible de demander la valeur du registre d'état. Pour cela il faut envoyer l'octet <tt>0xD7</tt> sur le bus SPI, une fois la mémoire sélectionnée. Ensuite, il faut lire les deux octets du registre d'état puis remonter la ligne de sélection à l'état haut.

== Test de la mémoire MT29F128G8 ==

Cette mémoire est sélectionnée par défaut. Il faut juste arriver à lui envoyer un ordre en utilisant les 8 lignes de contrôle.

= Bibliothèque LUFA =

Pour la gestion du bus USB par le micro-contrôleur nous allons nous appuyer au maximum sur la bibliothèque USB LUFA. Cette bibliothèque permet d'exploiter plus facilement les aspects USB des micro-contrôleurs AVR comme l'ATMega16u2.

Vous pouvez télécharger la dernière version de la bibliothèque [http://www.fourwalledcubicle.com/LUFA.php]. Il est ensuite conseillé d'effectuer quelques manipulations pour pouvoir développer dans de bonnes conditions.
* Créez un répertoire <tt>PolytechLille</tt> au même niveau que les répertoires <tt>Demos</tt> et <tt>Projects</tt>.
* Dans ce répertoire copiez la démonstration de périphérique USB bas niveau <tt>MassStorage</tt>. Au niveau du <tt>makefile</tt> indiquez <tt>atmega16u2</tt> comme micro-contrôleur, <tt>UNO</tt> comme platine et restez à 8Mhz.
* Il faut ensuite modifier la configuration de la mémoire et les fonctions d'accès à cette mémoire dans le sous-répertoire <tt>Lib</tt> du répertoire <tt>PolytechLille/MassStorage</tt>.

Pour téléverser votre programme sur l’<tt>ATMega16u2</tt>, le paquetage Debian <tt>dfu-programmer</tt> est nécessaire. Installez-le au besoin. La procédure à suivre pour charger votre programme sur l’<tt>ATMega16u2</tt> est la suivante :

* court-circuitez momentanément les lignes reset et masse de l’<tt>ATMega16u2</tt>, l'utilitaire <tt>lsusb</tt> doit lister la carte comme étant en mode DFU, vous pouvez alors exécuter les commandes suivantes :
** <tt>dfu-programmer atmega16u2 erase</tt>
** <tt>dfu-programmer atmega16u2 flash MassStorage.hex</tt>
** <tt>dfu-programmer atmega16u2 reset</tt>
* débranchez et rebranchez votre carte, votre programme doit être actif sur le micro-contrôleur.

= Réalisations des binômes =

{| class="wikitable"
! Numéro !! Elèves !! Fonctionnalité supplémentaire !! Page
|-
| Binôme 1
| Nicolas DEBAISIEUX & Maxence FLAMENT
| Affichage température par leds
| [[Binome2019-1|Binôme 1 2019/2020]]
|-
| Binôme 2
| Eve POITEVIN & Alix DUFOUR
| Déverrouillage par haut volume sonore
| [[Binome2019-2|Binôme 2 2019/2020]]
|-
| Binôme 3
| Corentin GIELIN & Julien DUMON
| Afficheurs 7-seg en tant que vumètre numérique
| [[Binome2019-3|Binôme 3 2019/2020]]
|-
| Binôme 4
| Clément DELECOURT & Thomas MOSTOWFI
| Signal mauvaise orientation
| [[Binome2019-4|Binôme 4 2019/2020]]
|-
| Binôme 5
| Gaëtan DELPLANQUE & Tristan PAYEN
| Verrouillage code
| [[Binome2019-5|Binôme 5 2019/2020]]
|-
| Binôme 6
| Louise MAES & Léo POUMAER
| Ecran LCD + vumètre + affichage nom fichier
| [[Binome2019-6|Binôme 6 2019/2020]]
|-
| Binôme 7
| Martin SERGEANT & Quirin DECAUDIN
|
| [[Binome2019-7|Binôme 7 2019/2020]]
|-
| Binôme 8
| Mateo POURRIER & Martin PLAUD
|
| [[Binome2019-8|Binôme 8 2019/2020]]
|-
| Binôme 9
| Baptiste BLACK & Alexandre ROUSSEL
| Hub
| [[Binome2019-9|Binôme 9 2019/2020]]
|-
| Binôme 10
| Theo DELAUNOIS & Antoine MALENGE
|
| [[Binome2019-10|Binôme 10 2019/2020]]
|-
| Binôme 11
| Florian DERLIQUE & Ahimen BENDIF
|
| [[Binome2019-11|Binôme 11 2019/2020]]
|-
|}

Binome2019-9

2020-02-10T08:29:17Z

Aroussel :

Binome2019-9

2020-02-10T08:20:39Z

Aroussel :

==Partie Réflexion==

Nous avons 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

Binome2019-9

2020-02-10T08:00:27Z

Aroussel :

nous avons 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

Binome2019-9

2020-01-27T09:36:01Z

Aroussel :

nous avons 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
-

Binome2019-9

2020-01-27T09:33:11Z

Aroussel :

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

-un haut-parleur à fonctionnalité de vumètre (bruitage lors du remplissage, de la connexion, etc)
-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)
-

Binome2019-9

2020-01-27T09:27:20Z

Aroussel :

BE 2019-2020

2020-01-27T09:24:33Z

Aroussel : /* Réalisations des binômes */

= Présentation du bureau d'étude =

Nous vous proposons de découvrir ce qu'est réellement cet objet devenu banal appelé clé USB (Universal Serial Bus).

[[File:Firefly-serenity-usb-flash-drive.jpg|thumb|center|200px]]

Le bureau d'étude consiste à construire de A à Z une clé USB :
* en créant un circuit électronique ou PCB (Printed Circuit Board) à l’aide d’un logiciel ;
* en soudant des composants électroniques (micro-contrôleur, mémoire FLASH, ...) ;
* en programmant le micro-contrôleur pour gérer la communication USB en utilisant la bibliothèque LUFA (Lightweight USB Framework for AVRs) ;
* en programmant le micro-contrôleur pour accéder à la mémoire ;
* en fabriquant un beau boitier pour votre clef.

Pour personnaliser votre clé n'hésitez pas à ajouter des fonctionnalités :
* LED qui clignotent lors des accès en lecture ou écriture ;
* vumètre qui indique le remplissage de la clé ;
* micro-interrupteurs pour verrouiller la clé ;
* vibreur parce que c'est possible, vous trouverez bien une justification ;
* microphone permettant d’espionner les conversations ;
* toute autre fonction plus ou moins utile mais qui vous inspire ...

Les supports de la présentation de ce bureau d'études : [[Media:BE_clef_USB.pdf]].

= Survol d'USB =

== Evolution des connexions USB ==

L'acronyme USB signifie "Universal Serial Bus" et effectivement l'USB peut être défini comme un bus USB très verbeux. L'USB est géré par un consortium autonome "USB Implementers Forum".

[[File:USB-2.png|thumb|left|300px]] Jusqu'à la version 2, l'acronyme est fidèle à la réalité. Pour ces périphériques, 3 vitesses de transfert sont possibles sur la paire différentielle :
* basse vitesse : 1,5 Mb/s ;
* pleine vitesse : 12 Mb/s ;
* haute vitesse : 480 Mb/s.
<br style="clear: both;"/>
[[File:USB-3.jpg|thumb|right|300px]] A partir de l'USB 3.0, la notion de bus série est un peu oubliée. La vitesse augmente en utilisant les deux nouvelles paires blindées : 5Gb/s (super vitesse).
<br style="clear: both;"/>
[[File:USB-4.png|thumb|left|500px]] Et maintenant USB (USB 3.1, USB 3.2, USB 4) se prend pour de l'Ethernet. En effet, le connecteur USB-C ajoute, à la paire historique, quatre paires blindées. USB 3.2 promet des vitesses jusqu'à 20G/s.
<br style="clear: both;"/>

== Un protocole verbeux ==

[[File:USB-communication.gif|thumb|left|600px]]
L'initialisation d'un périphérique USB se fait comme suit :
* détection électrique de la connexion du périphérique ;
* alimentation électrique du périphérique ;
* utilisation de l'adresse temporaire 0 sur le bus ;
* récupération de la taille des messages pour le point d'accès 0 ;
* envoi de l'adresse au périphérique sur le point d'accès 0 ;
* envoi des descripteurs du périphérique au contrôleur USB via le point d'accès 0.
Pour un périphérique simple :
* souris : environ 100 octets pour le descripteur de configuration ;
* clavier : environ 150 octets pour le descripteur de configuration.
<br style="clear: both;"/>

[[File:USB-descripteurs.gif|thumb|right|700px]]
Les points d'accès (terminaison sur le schéma) :
* des identifiants sur 8 bits (numéro sur 4 bits) ;
* un point d'accès de contrôle de numéro 0 bidirectionnel ;
* les communications se font de ou vers les points d'accès ;
* un sens de communication (bit de poid fort) :
** IN => du périphérique vers le contrôleur ;
** OUT => du contrôleur vers le périphérique.
* la direction est IN ou OUT vis à vis de l’hôte.
Plusieurs types de points d'accès :
* isodromique (isochronous) : débit réservé (e.g. vidéo en temps réel) ;
* par interruption (interrupt) : latence garantie (e.g. souris) ;
* de volume (bulk) : débit maximal sans garantie (e.g. clef mémoire).
<br style="clear: both;"/>

= Les composants électroniques =

[[File:atmega16u2.png|thumb|left|200px|ATMega16u2]]
Le coeur de votre clé va être un micro-contrôleur AVR plus exactement l'ATMega16u2. Ce micro-contrôleur possède l'électronique nécessaire pour la gestion d'un bus USB 2.0.
<br style="clear: both;"/>

[[File:adesto64Mb.jpg|thumb|left|200px|AT45DB641E-SHN2B-T]]
[[File:MT29F128G08.jpg|thumb|right|200px|MT29F128G8]]
Sans mémoire une clé n'est pas une clé. Vous utiliserez des mémoires faciles à gérer avec un ATMega16u2. Ces mémoires sont accessibles par un bus série SPI et facile à souder. Par contre elles sont de faible capacité (64Mb). Si vous êtes téméraire, vous pouvez utiliser une mémoire accessible par un bus de 8 bits, plus difficile à souder, plus difficile à programmer mais d'une capacité intéressante (128Gb).
<br style="clear: both;"/>

Il vous faudra aussi quelques autres composants comme un quartz, des résistances, des condensateurs, des diodes, des régulateurs de tension et bien sur des LED pour ajouter un peu de lumière. La carte de base peut être décrite comme suit.
* Le micro-contrôleur peut être accompagné d'un quartz à 8Mhz et de ses condensateurs et résistance.
* Le micro-contrôleur peut être alimenté par le connecteur USB en 5v (broche UVCC) mais avec ses lignes VCC et AVCC bouclées sur la sortie UCAP du régulateur 3.3v interne.
* Un convertisseur 5v vers 3.3v est nécessaire pour l'alimentation des mémoires.
* Le micro-contrôleur dialogue avec les mémoires par le bus SPI, une ligne de sélection est nécessaire par mémoire.

Pour la conception de votre clé vous pouvez vous appuyer sur un prototype de clef réalisé pour ce bureau d'études.

[[File:cle_usb_schema.png|thumb|left|400px|Schéma électronique]]
[[File:clef_usb_pcb.png|thumb|right|400px|Carte électronique]]
<br style="clear: both;"/>
Le schéma décrit le circuit électronique partie par partie.
A partir du circuit, il faut créer une carte sans croisement de pistes pour éviter les court-circuits.
Le fichier source Fritzing est disponible : [[Media:cle_usb.zip]] (renommer en <tt>.fzz</tt>).

Une autre carte est disponible pour une mémoire parallèle de plus grande capacité. Attention cette carte n'a pas été testée.

[[File:cle_usb_bis_schema.png|thumb|left|400px|Schéma électronique]]
[[File:clef_usb_bis_pcb.png|thumb|right|400px|Carte électronique]]
<br style="clear: both;"/>
Le fichier source Fritzing est disponible : [[Media:cle_usb_bis.zip]] (renommer en <tt>.fzz</tt>).

= Logiciels =

Pour la conception de circuits imprimés nous vous recommandons le logiciel [http://fritzing.org/home/ fritzing].

Pour la découpe laser de nombreux utilisateurs utilisent [https://inkscape.org/fr/ inkscape].

Pour la conception 3D vous pouvez tenter [http://www.freecadweb.org/?lang=fr_FR freeCAD]. Une solution en ligne existe : [https://www.onshape.com/ onshape].

Pour la programmation du micro-contrôleur vous utiliserez le compilateur C <tt>avr-gcc</tt> et le logiciel de téléversement <tt>dfu-programmer</tt>.

= Bibliothèque LUFA =

Pour la gestion du bus USB par le micro-contrôleur nous allons nous appuyer au maximum sur la bibliothèque USB LUFA. Cette bibliothèque permet d'exploiter plus facilement les aspects USB des micro-contrôleurs AVR comme l'ATMega16u2.

Vous pouvez télécharger la dernière version de la bibliothèque [http://www.fourwalledcubicle.com/LUFA.php]. Il est ensuite conseillé d'effectuer quelques manipulations pour pouvoir développer dans de bonnes conditions.
* Créez un répertoire <tt>PolytechLille</tt> au même niveau que les répertoires <tt>Demos</tt> et <tt>Projects</tt>.
* Dans ce répertoire copiez la démonstration de périphérique USB bas niveau <tt>MassStorage</tt>. Au niveau du <tt>makefile</tt> indiquez <tt>atmega16u2</tt> comme micro-contrôleur, <tt>UNO</tt> comme platine et restez à 8Mhz.
* Il faut ensuite modifier la configuration de la mémoire et les fonctions d'accès à cette mémoire dans le sous-répertoire <tt>Lib</tt> du répertoire <tt>PolytechLille/MassStorage</tt>.

Pour téléverser votre programme sur l’<tt>ATMega16u2</tt>, le paquetage Debian <tt>dfu-programmer</tt> est nécessaire. Installez-le au besoin. La procédure à suivre pour charger votre programme sur l’<tt>ATMega16u2</tt> est la suivante :

* court-circuitez momentanément les lignes reset et masse de l’<tt>ATMega16u2</tt>, l'utilitaire <tt>lsusb</tt> doit lister la carte comme étant en mode DFU, vous pouvez alors exécuter les commandes suivantes :
** <tt>dfu-programmer atmega16u2 erase</tt>
** <tt>dfu-programmer atmega16u2 flash MassStorage.hex</tt>
** <tt>dfu-programmer atmega16u2 reset</tt>
* débranchez et rebranchez votre carte, votre programme doit être actif sur le micro-contrôleur.

= Réalisations des binômes =

{| class="wikitable"
! Numéro !! Elèves !! Fonctionnalité supplémentaire !! Page
|-
| Binôme 1
| Nicolas DEBAISIEUX & Maxence FLAMENT
|
| [[Binome2019-1|Binôme 1 2019/2020]]
|-
| Binôme 2
| Eve POITEVIN & Alix DUFOUR
| Synthèse vocale
| [[Binome2019-2|Binôme 2 2019/2020]]
|-
| Binôme 3
| Corentin GIELIN & Julien DUMON
|
| [[Binome2019-3|Binôme 3 2019/2020]]
|-
| Binôme 4
| Clément DELECOURT & Thomas MOSTOWFI
|
| [[Binome2019-4|Binôme 4 2019/2020]]
|-
| Binôme 5
| Gaêtan DELPLANQUE & Tristan PAYEN
|
| [[Binome2019-5|Binôme 5 2019/2020]]
|-
| Binôme 6
| Louise MAES & Léo POUMAER
|
| [[Binome2019-6|Binôme 6 2019/2020]]
|-
| Binôme 7
| Martin SERGEANT & Quirin DECAUDIN
|
| [[Binome2019-7|Binôme 7 2019/2020]]
|-
| Binôme 8
| Mateo POURRIER & Martin PLAUD
|
| [[Binome2019-8|Binôme 8 2019/2020]]
|-
| Binôme 9
| Baptiste BLACK & Alexandre ROUSSEL
| Haut-parleur
| [[Binome2019-9|Binôme 9 2019/2020]]
|-
| Binôme 10
| Theo DELAUNOIS & Antoine MALENGE
|
| [[Binome2019-10|Binôme 10 2019/2020]]
|-
| Binôme 11
| Florian DERLIQUE & Ahimen BENDIF
|
| [[Binome2019-11|Binôme 11 2019/2020]]
|-
| Binôme 12
| Prénom Nom & Prénom Nom
|
| [[Binome2019-12|Binôme 12 2019/2020]]
|-
|}

Binome2019-9

2020-01-27T09:22:25Z

Aroussel :

Binome2019-9

2020-01-27T09:20:30Z

Aroussel :

Binome2019-9

2020-01-27T09:13:11Z

Aroussel :

Fonctionnalité,idée 1 : haut-parleur à fonctionnalité de vumètre (bruitage lors du remplissage, de la connexion, etc)
idée 2 :

Binome2019-9

2020-01-27T09:10:26Z

Aroussel : Page créée avec « Fonctionnalité,idée 1 : haut-parleur à fonctionnalité de vumètre »

Fonctionnalité,idée 1 : haut-parleur à fonctionnalité de vumètre

BE 2019-2020

2020-01-27T09:09:48Z

Aroussel : /* Réalisations des binômes */

= Présentation du bureau d'étude =

Nous vous proposons de découvrir ce qu'est réellement cet objet devenu banal appelé clé USB (Universal Serial Bus).

[[File:Firefly-serenity-usb-flash-drive.jpg|thumb|center|200px]]

Le bureau d'étude consiste à construire de A à Z une clé USB :
* en créant un circuit électronique ou PCB (Printed Circuit Board) à l’aide d’un logiciel ;
* en soudant des composants électroniques (micro-contrôleur, mémoire FLASH, ...) ;
* en programmant le micro-contrôleur pour gérer la communication USB en utilisant la bibliothèque LUFA (Lightweight USB Framework for AVRs) ;
* en programmant le micro-contrôleur pour accéder à la mémoire ;
* en fabriquant un beau boitier pour votre clef.

Pour personnaliser votre clé n'hésitez pas à ajouter des fonctionnalités :
* LED qui clignotent lors des accès en lecture ou écriture ;
* vumètre qui indique le remplissage de la clé ;
* micro-interrupteurs pour verrouiller la clé ;
* vibreur parce que c'est possible, vous trouverez bien une justification ;
* microphone permettant d’espionner les conversations ;
* toute autre fonction plus ou moins utile mais qui vous inspire ...

Les supports de la présentation de ce bureau d'études : [[Media:BE_clef_USB.pdf]].

= Survol d'USB =

== Evolution des connexions USB ==

L'acronyme USB signifie "Universal Serial Bus" et effectivement l'USB peut être défini comme un bus USB très verbeux. L'USB est géré par un consortium autonome "USB Implementers Forum".

[[File:USB-2.png|thumb|left|300px]] Jusqu'à la version 2, l'acronyme est fidèle à la réalité. Pour ces périphériques, 3 vitesses de transfert sont possibles sur la paire différentielle :
* basse vitesse : 1,5 Mb/s ;
* pleine vitesse : 12 Mb/s ;
* haute vitesse : 480 Mb/s.
<br style="clear: both;"/>
[[File:USB-3.jpg|thumb|right|300px]] A partir de l'USB 3.0, la notion de bus série est un peu oubliée. La vitesse augmente en utilisant les deux nouvelles paires blindées : 5Gb/s (super vitesse).
<br style="clear: both;"/>
[[File:USB-4.png|thumb|left|500px]] Et maintenant USB (USB 3.1, USB 3.2, USB 4) se prend pour de l'Ethernet. En effet, le connecteur USB-C ajoute, à la paire historique, quatre paires blindées. USB 3.2 promet des vitesses jusqu'à 20G/s.
<br style="clear: both;"/>

== Un protocole verbeux ==

[[File:USB-communication.gif|thumb|left|600px]]
L'initialisation d'un périphérique USB se fait comme suit :
* détection électrique de la connexion du périphérique ;
* alimentation électrique du périphérique ;
* utilisation de l'adresse temporaire 0 sur le bus ;
* récupération de la taille des messages pour le point d'accès 0 ;
* envoi de l'adresse au périphérique sur le point d'accès 0 ;
* envoi des descripteurs du périphérique au contrôleur USB via le point d'accès 0.
Pour un périphérique simple :
* souris : environ 100 octets pour le descripteur de configuration ;
* clavier : environ 150 octets pour le descripteur de configuration.
<br style="clear: both;"/>

[[File:USB-descripteurs.gif|thumb|right|700px]]
Les points d'accès (terminaison sur le schéma) :
* des identifiants sur 8 bits (numéro sur 4 bits) ;
* un point d'accès de contrôle de numéro 0 bidirectionnel ;
* les communications se font de ou vers les points d'accès ;
* un sens de communication (bit de poid fort) :
** IN => du périphérique vers le contrôleur ;
** OUT => du contrôleur vers le périphérique.
* la direction est IN ou OUT vis à vis de l’hôte.
Plusieurs types de points d'accès :
* isodromique (isochronous) : débit réservé (e.g. vidéo en temps réel) ;
* par interruption (interrupt) : latence garantie (e.g. souris) ;
* de volume (bulk) : débit maximal sans garantie (e.g. clef mémoire).
<br style="clear: both;"/>

= Les composants électroniques =

[[File:atmega16u2.png|thumb|left|200px|ATMega16u2]]
Le coeur de votre clé va être un micro-contrôleur AVR plus exactement l'ATMega16u2. Ce micro-contrôleur possède l'électronique nécessaire pour la gestion d'un bus USB 2.0.
<br style="clear: both;"/>

[[File:adesto64Mb.jpg|thumb|left|200px|AT45DB641E-SHN2B-T]]
[[File:MT29F128G08.jpg|thumb|right|200px|MT29F128G8]]
Sans mémoire une clé n'est pas une clé. Vous utiliserez des mémoires faciles à gérer avec un ATMega16u2. Ces mémoires sont accessibles par un bus série SPI et facile à souder. Par contre elles sont de faible capacité (64Mb). Si vous êtes téméraire, vous pouvez utiliser une mémoire accessible par un bus de 8 bits, plus difficile à souder, plus difficile à programmer mais d'une capacité intéressante (128Gb).
<br style="clear: both;"/>

Il vous faudra aussi quelques autres composants comme un quartz, des résistances, des condensateurs, des diodes, des régulateurs de tension et bien sur des LED pour ajouter un peu de lumière. La carte de base peut être décrite comme suit.
* Le micro-contrôleur peut être accompagné d'un quartz à 8Mhz et de ses condensateurs et résistance.
* Le micro-contrôleur peut être alimenté par le connecteur USB en 5v (broche UVCC) mais avec ses lignes VCC et AVCC bouclées sur la sortie UCAP du régulateur 3.3v interne.
* Un convertisseur 5v vers 3.3v est nécessaire pour l'alimentation des mémoires.
* Le micro-contrôleur dialogue avec les mémoires par le bus SPI, une ligne de sélection est nécessaire par mémoire.

Pour la conception de votre clé vous pouvez vous appuyer sur un prototype de clef réalisé pour ce bureau d'études.

[[File:cle_usb_schema.png|thumb|left|400px|Schéma électronique]]
[[File:clef_usb_pcb.png|thumb|right|400px|Carte électronique]]
<br style="clear: both;"/>
Le schéma décrit le circuit électronique partie par partie.
A partir du circuit, il faut créer une carte sans croisement de pistes pour éviter les court-circuits.
Le fichier source Fritzing est disponible : [[Media:cle_usb.zip]] (renommer en <tt>.fzz</tt>).

Une autre carte est disponible pour une mémoire parallèle de plus grande capacité. Attention cette carte n'a pas été testée.

[[File:cle_usb_bis_schema.png|thumb|left|400px|Schéma électronique]]
[[File:clef_usb_bis_pcb.png|thumb|right|400px|Carte électronique]]
<br style="clear: both;"/>
Le fichier source Fritzing est disponible : [[Media:cle_usb_bis.zip]] (renommer en <tt>.fzz</tt>).

= Logiciels =

Pour la conception de circuits imprimés nous vous recommandons le logiciel [http://fritzing.org/home/ fritzing].

Pour la découpe laser de nombreux utilisateurs utilisent [https://inkscape.org/fr/ inkscape].

Pour la conception 3D vous pouvez tenter [http://www.freecadweb.org/?lang=fr_FR freeCAD]. Une solution en ligne existe : [https://www.onshape.com/ onshape].

Pour la programmation du micro-contrôleur vous utiliserez le compilateur C <tt>avr-gcc</tt> et le logiciel de téléversement <tt>dfu-programmer</tt>.

= Bibliothèque LUFA =

Pour la gestion du bus USB par le micro-contrôleur nous allons nous appuyer au maximum sur la bibliothèque USB LUFA. Cette bibliothèque permet d'exploiter plus facilement les aspects USB des micro-contrôleurs AVR comme l'ATMega16u2.

Vous pouvez télécharger la dernière version de la bibliothèque [http://www.fourwalledcubicle.com/LUFA.php]. Il est ensuite conseillé d'effectuer quelques manipulations pour pouvoir développer dans de bonnes conditions.
* Créez un répertoire <tt>PolytechLille</tt> au même niveau que les répertoires <tt>Demos</tt> et <tt>Projects</tt>.
* Dans ce répertoire copiez la démonstration de périphérique USB bas niveau <tt>MassStorage</tt>. Au niveau du <tt>makefile</tt> indiquez <tt>atmega16u2</tt> comme micro-contrôleur, <tt>UNO</tt> comme platine et restez à 8Mhz.
* Il faut ensuite modifier la configuration de la mémoire et les fonctions d'accès à cette mémoire dans le sous-répertoire <tt>Lib</tt> du répertoire <tt>PolytechLille/MassStorage</tt>.

Pour téléverser votre programme sur l’<tt>ATMega16u2</tt>, le paquetage Debian <tt>dfu-programmer</tt> est nécessaire. Installez-le au besoin. La procédure à suivre pour charger votre programme sur l’<tt>ATMega16u2</tt> est la suivante :

* court-circuitez momentanément les lignes reset et masse de l’<tt>ATMega16u2</tt>, l'utilitaire <tt>lsusb</tt> doit lister la carte comme étant en mode DFU, vous pouvez alors exécuter les commandes suivantes :
** <tt>dfu-programmer atmega16u2 erase</tt>
** <tt>dfu-programmer atmega16u2 flash MassStorage.hex</tt>
** <tt>dfu-programmer atmega16u2 reset</tt>
* débranchez et rebranchez votre carte, votre programme doit être actif sur le micro-contrôleur.

= Réalisations des binômes =

{| class="wikitable"
! Numéro !! Elèves !! Fonctionnalité supplémentaire !! Page
|-
| Binôme 1
| Nicolas DEBAISIEUX & Maxence FLAMENT
|
| [[Binome2019-1|Binôme 1 2019/2020]]
|-
| Binôme 2
| Eve Poitevin & Alix Dufour
|
| [[Binome2019-2|Binôme 2 2019/2020]]
|-
| Binôme 3
| Corentin Gielen & Julien Dumon
|
| [[Binome2019-3|Binôme 3 2019/2020]]
|-
| Binôme 4
| Clément DELECOURT & Thomas MOSTOWFI
|
| [[Binome2019-4|Binôme 4 2019/2020]]
|-
| Binôme 5
| Gaêtan DELPLANQUE & Tristan PAYEN
|
| [[Binome2019-5|Binôme 5 2019/2020]]
|-
| Binôme 6
| Louise MAES & Léo POUMAER
|
| [[Binome2019-6|Binôme 6 2019/2020]]
|-
| Binôme 7
| Martin SERGEANT & Quirin DECAUDIN
|
| [[Binome2019-7|Binôme 7 2019/2020]]
|-
| Binôme 8
| Mateo POURRIER & Martin PLAUD
|
| [[Binome2019-8|Binôme 8 2019/2020]]
|-
| Binôme 9
| Baptiste BLACK & Alexandre ROUSSEL
|
| [[Binome2019-9|Binôme 9 2019/2020]]
|-
| Binôme 10
| Prénom Nom & Prénom Nom
|
| [[Binome2019-10|Binôme 10 2019/2020]]
|-
|}