Binome2020-12
INTRODUCTION
L'objectif de ce bureau d'étude est la conception et la réalisation d'une clé USB personnalisée.
Les idées de personnalisations sont les suivantes :
- Flash grosse capacité
- Led RGB qui change de couleur en fonction du remplissage
- "Bouton d'urgence" efface l'intégralité de la clé après une longue pression (en jouant des animations sur la LED ?)
Compétences et matériel utilisé
HARDWARE
Solutions techniques
Stockage
Pour la fonction principale de la clé nous utiliserons une mémoire NAND produite chez micron. Cette mémoire de 128Gb nous permet d'obtenir un stockage total de 16 Go.
Pour interfacer cette mémoire, nous utilisons un micro contrôleur utilisant une architecture AVR. Celui en utilisé possède en plus une interface USB native pour communiquer avec l'ordinateur.
Personnalisation
Pour nos idées de personnalisation nous devons utiliser deux leds cote à cote (une rouge et une verte) ainsi que leur résistances.
Le bouton d'effacement d'urgence "Press Only when Rightfully Needed" (POwRN) nécessite une résistance "Pull-Up". Nous avons décider d'utiliser la résistance interne de notre micro contrôleur.
Afin de gérer ces fonction indépendamment de la mémoire nous utiliserons d’abord un deuxième micro contrôleur esclave (AtTiny) qui communiquera au maitre via software-serial.
Application
Rev 1.1
Pour la seconde séance de BE nous avons réalisé un premier schématic et une première version de PCB pour notre clé USB. Après concertation avec les professeurs, certains composants n'étaient pas adéquats ou utilisable sur notre clé USB, nous avons donc modifié la clé USB.
Rev 1.2
Pour la version 1.2 de la clé USB, nous avons modifié le régulateur, nous sommes passé de 1 LED à 2 LEDs différentes, ainsi que les connecteurs. Nous avons aussi ajouté des jumpers.
Rev 1.3
Cette version (celle que nous avons commandé) a vu apparaitre de nombreuses modifications telles que :
- Connexion des pins Rdy2 et MS2 entre la mémoire et le microcontrôleur
- Remplacement des jumpers par des petits interrupteurs
- Ajout de l'interface de programmation (6 pins standards)
- Rétrécissement global du PCB de Gomator ( Surface de la clé réduite de moitié)
Nous sommes ensuite passé au soudage de la clé USB après avoir reçu la commande effectué sur le site Mouser.
Voici le résultat :
Cependant, après avoir fait des essais avec cette clé USB, il semblait y avoir des problèmes de téléversement sur la clé USB. Elle semblait donc inutilisable.
Nous avons fait appel au professeur qui nous a sympathiquement resoudé une grosse partie de notre clé USB.
Voici la seconde clé USB soudée :
Avec cette clé USB, nous sommes capable de téléverser des programmes dans les deux cartes de la clé, et donc de la programmer afin de pouvoir communiquer avec la mémoire.
Rev 2.0
Cette version contient les correctifs nécessaires pour régler les soucis découvert sur la rev 1.3.
Les modifications majeures sont :
- Utilisation du régulateur interne de l'AtMega
- Connexion du reset des IC avec le reset des ICSP
- Affinement de la forme générale de la clé
Cette version de la clé n'a jamais vu le jour.
SOFTWARE
Introduction
Afin de tester la clé et de développer son logiciel nous avons décidé de segmenter le programme en 7 parties :
- Tester l'ATmega à l'aide d'un Blink
- Tester l'ATtiny à l'aide d'un Blink
- Faire communiquer les deux puces en Serial
- Faire communiquer l'ATmega en USB avec l'hote en utilisant Lufa
- Interfacer l'ATmega avec la mémoire
- Interfacer la mémoire en USB
- Ajouter nos personnalisation au code précédent
Premières communication avec la puce
Après avoir souder la première version de notre PCB, nous avons essayer de communiquer avec elle. Cependant, la première version ne communiquais pas (le DFU n’apparaissait pas). Nous avons essayé de communiqué via un ICSP. C’était encore un échec.
Nous avons ensuite décidé de souder une clé avec uniquement le minimum nécessaire. Après 1h d'échec avec le port USB droit de mon ordi, nous avons tenter d'utiliser le port de gauche. C'est un succès, la clé apparais dans USB Dev View (/mettre photo USB dev view/)
Nous téleversons un programma Blink (/screen du code/). C'est avec horreur que nous découvrons que la led clignote 8 fois trop lentement, et pire encore : le DFU n’apparais plus.
La séance suivante à été consacré à se battre avec un adaptateur USB-ICSP pour chenger les e-fuse de l'ATmega. A la fin de la séance, la led clignotait à la bonne vitesse. Cependant le DFU reste introuvable.
La configuration des e-fuses est comme ceci :
| Configuration des fuses | |||||
|---|---|---|---|---|---|
| Fuse : | lfuse | hfuse | efuse | ||
| Valeurs: | 4E | D9 | F6 | ||
Installation de LUFA
Après avoir vu que quelques éléments vitaux de la clé fonctionne, nous avons téléversé une démo de LUFA. C'est avec un grand plaisir que nous observons Windows reconnaitre le périphérique USB. La prochaine étape consiste à sous traiter la réalisation de la bibliothèque de communication avec la Nand par le binome 4.
Code complet de l'AT Tiny
Voici le code complet de l'AT Tiny, il permet d'envoyer un message au micro contrôleur principale afin d'effacer le contenu de la clé USB lorsque l'on appuie 10 secondes sur le bouton de la clé. Il permet aussi d'afficher le taux de remplissage de la clé USB à l'aide des deux LEDs, en faisant varier la tension des LEDs grâce à un signal PWM afin de faire varier la couleur.
#include <SoftwareSerial.h>
const byte rxPin = 2;
const byte txPin = 3;
const int led1 = 5;
const int led2 = 6;
const int btn = 7;
int remp = 0;
String data = "";
SoftwareSerial mySerial(2,3);
void setup() {
pinMode(7,INPUT);//btn
pinMode(led1,OUTPUT);//led1
pinMode(led2, OUTPUT);//led2
pinMode(rxPin, INPUT);
pinMode(txPin, OUTPUT);
mySerial.begin(9600);
digitalWrite(led1,LOW);
digitalWrite(led2,LOW);
}
void loop() {
if (mySerial.available() >0){
data = mySerial.readStringUntil("A");
}
remp = data.toInt();
led(remp);
if (digitalRead(btn) == HIGH){
mySerial.write("R");
for (int i =100; i<1; i--){
led(i);
delay(10);
}
}
}
void led(int remplissage){//remplissage en pourcent
analogWrite(led1, map(remplissage,0,100,0,255));
analogWrite(led2, map(remplissage,0,100,255,0));
}
Exemple de téléversement d'un code vers la carte avec succès :
Code Test de l'AT Mega N°1
Ce code a été fait par notre groupe, il nous a pris 4 séances de bureau d'études à concevoir. Son objectif est de demander à la mémoire son ID et donc de vérifier son bon fonctionnement. Pour cela nous envoyons à la mémoire la commande : 0x90 puis l'adresse 0x00. Nous attendons en retour 7 bytes, le byte 0 devrait être 0x2c. Afin d'afficher les données renvoyées par la mémoire, nous faisons clignoter la LED 2 fois pour 1 et 1 fois pour 0, et nous séparons les bytes par l'allumage de la LED pendant 2.5 secondes.
Ce code ne fonctionnait pas, il ne renvoyait que des 0 pour le 1er byte, puis ensuite n'envoyait que des 1. Nous avons donc tenté de passer par la bibliothèque du binôme N°4.
#include <xc.h>
#include <util/delay.h>
#define F_CPU 16000000L
//PC5 default low Command latch
//PC6 default low Adress latch
//PC7 default high "Write" command
//PD5 default high "read" command
//PD6 always low
//Rdy1 = PD4
//Rdy2 = PD1
//led = PD2
unsigned char busData = 0x00;
int writeBus(unsigned char data){
unsigned char new_val = 0;
if (data & 0x01) new_val |= 0x80;//Inverse le Byte car notre bus est inversé
if (data & 0x02) new_val |= 0x40;
if (data & 0x04) new_val |= 0x20;
if (data & 0x08) new_val |= 0x10;
if (data & 0x10) new_val |= 0x08;
if (data & 0x20) new_val |= 0x04;
if (data & 0x40) new_val |= 0x02;
if (data & 0x80) new_val |= 0x01;
DDRB = 0xff;//Met le bus en Output
PORTB = new_val;//Ecrit le Byte inversé sur le PORT du bus
}
int command(unsigned char command){
writeBus(command);
PORTC = 0b00100000;//WE low,ALE Low, CLE High
_delay_ms(1);
PORTC = 0b10000000;//WE High, rest low
}
int adress(unsigned char adress){
writeBus(adress);
PORTC = 0b01000000;//WE Low, ALE High,CLE Low
_delay_ms(1);
PORTC = 0b10000000;//WE High, rest low
}
int dataOut(void){
DDRB = 0x00;
PORTD &= (0<<PD5);//Met RE Low
_delay_ms(1);
busData = PINB;//Read le bus
for(int i = 0; i < 8; i++){//Parcours le Byte vu sur le bus
_delay_ms(1000);
if(busData & (0b00000001<<i)) {//Clignote 2 fois si le bit = 1
PORTD |= (1<<PD2);
_delay_ms(200);
PORTD &= (0<<PD2);
_delay_ms(200);
PORTD |= (1<<PD2);
_delay_ms(200);
PORTD &= (0<<PD2);
}
else{ //Clignote 1 fois si le bit = 0
PORTD |= (1<<PD2);
_delay_ms(200);
PORTD &= (0<<PD2);
}
}
_delay_ms(1000);
PORTD |= (1<<PD5);//Met RE High
_delay_ms(1);
}
int main(void)
{
DDRB = 0xff;
DDRC = 0b11100000;
DDRD = 0b11100100;
PORTB =0x00;
PORTC = 0b10000000;
PORTD = 0b00100000;//standby
while(1)
{
command(0x90);
_delay_ms(1);
adress(0x00);
_delay_ms(1);//Commandes et adress pour Read ID
for(int i = 0; i < 4; i++){
PORTD |= (1<<PD2);
_delay_ms(2500);
PORTD &= (0<<PD2);
PORTD |= (1<<PD2);
_delay_ms(2500);
PORTD &= (0<<PD2);
dataOut();
}
}
}
Code Test de l'AT Mega N°2 (Bibliothèque du Binome 4)
Ce code a le même objectif de le premier code test, mais nous avons utilisé la bibliothèque du binôme 4. Nous utilisons la commande "nand_read_id_long()" qui prend en paramètre un tableau et qui écrit les bytes à renvoyer à l'intérieur du tableau.
Ce code ne fonctionne pas non plus, il ne renvoyait que des 0.
#include <xc.h>
#include "nand.h"
unsigned char busData[4];
int main(void)
{
while(1)
{
nand_read_id_long(busData);//Programme de Albin
for(int k = 0;k<4;k++){// Parcours les 4 bytes renvoyés par la cart
_delay_ms(1000);
PORTD |= (1<<PD2);
_delay_ms(2500);
PORTD &= (0<<PD2);
for(int i = 0; i < 8; i++){// Parcours chaque bits d'un byte
_delay_ms(1000);
if(busData[k] & (0b00000001<<i)) {//Clignote deux fois si le bit =1
PORTD |= (1<<PD2);
_delay_ms(200);
PORTD &= (0<<PD2);
_delay_ms(200);
PORTD |= (1<<PD2);
_delay_ms(200);
PORTD &= (0<<PD2);
}
else{//Clignote une fois si le bit = 0
PORTD |= (1<<PD2);
_delay_ms(200);
PORTD &= (0<<PD2);
}
}
}
}
}
MECHANICAL
Rev 1
Nous avons décidé de fabriquer un boitier pour notre clé USB, pour cela nous sommes passé par le logiciel Fusion360. Nous avons conçu le boitier de sorte à ce qu'il soit imprimable en 3D. Pour commencer, nous avons exporter une version du PCB, nous l'avons mise sur Fusion360, puis nous avons conçu le boitier. Ensuite, il a fallu rajouter un logo ainsi que le nom de notre clé USB sur le dessus. Nous avons eu l'idée de faire sortir la LED de notre clé USB par l’œil de notre logo.
Pour fermer notre boitier, nous faisons dépasser des pins d'alignement que nous pourrons faire fondre afin de les souder sur le couvercle du boitier.
Nous avons choisi le thème des espions car l'effacement d'urgence de notre clé peut permettre aux espions de sauver leurs données des méchants.
Rev 2
La rev 2 est une version très proche de la rev 1 mais réduite en taille afin de coïncider avec le PCB de la rev 2.
Nous l'avons conçu en 3D de sorte à pouvoir l'imprimer grâce à une imprimante 3D dans le futur, voila le résultat :
CONCLUSION
Bilan Financier
A l'unité, cette clé USB coûte dans les "30€" à produire, et il est impensable de vendre ce genre d'objet à ce prix. Cependant, on pourrait s'intéresser à une production massive de cette clé USB. Une estimation d'expert affirme qu'il serait possible d'obtenir cette clé USB pour un prix allant de 2€ à 4€.
Bilan Temporel
Notre Bureau d'Etude s'est étalé sur une durée de 11 semaines, c'est à dire 46 heures de travail. La majorité de ces heures a été utilisé pour la programmation des deux puces de notre clé USB. Nous avons manqué de temps pour finaliser les fonctions les plus complexes à implémenter.
Bilan Technique
D'un point de vu technique, les améliorations proposées sur notre clé USB sont tout à fait envisageables. Nous réussissons à garder une taille convenable de clé USB. Pour une production de masse, il serait avisé d'utiliser des composants en BGA et des passifs plus petit permettant de réduire d'avantage la taille de la Clé. Il serait aussi possible de se passer des interfaces de programmation que nous avons utilisé tout au long de nos tests.
Pistes d'améliorations
Pour améliorer notre clé USB, il faudrait d'abord finaliser la programmation des deux puces. Il aurait été judicieux de choisir les petites mémoires au lieu de la grosse. Cela nous aurait permis de répartir de manière plus équitable le temps passé sur le software et hardware. Nous aurions pu par exemple développer des ajouts plus complexe. Penser que nous serions capable d'écrire et lire correctement sur la grosse mémoire avec notre faible niveau logiciel était ambitieux.
CHANGELOG
- 18/01/2021 : Mise en connaissance du BE, création du binôme, regroupement des idées d'améliorations pour la clé USB.
- 21/01/2021 : Avancement sur le Schematic et le PCB d'une première version de la clé USB.
- 25/01/2021 : Modification du Schematic et du PCB pour changer certains composants. Changement de version de clé.
- 28/01/2021 : Création du boitier (partie Mechanical), appréhension de la partie Software.
- 01/02/2021 : Passage à la Rev 3 de notre clé USB, modification du PCB et du Schematic, commande des composants (en partenariat avec le binome 4). Exercice de découverte de la partie Software (création d'un blink).
- 04/02/2021 : Appréhension de l'AVR-C, création d'un programme de "test" (Blink).
- 08/02/2021 : Recherche et tentative sur le serial en AVR-C.
- 11/02/2021 : Lecture de la datasheet de la mémoire.
- 15/02/2021 : Réception des premiers composants et renseignement sur LUFA.
- 18/02/2021 : Début du soudage du PCB de la clé USB (Passifs, micro-controlleurs).
- 08/03/2021 : Fin du soudage du PCB (Mémoire).
- 12/03/2021 : Tentative de communication avec la clé via le DFU, sans succès. (problème sur le Rst)
- 15/03/2021 : Communication réussie avec la clé via le DFU, après changement du PCB. Téléversement (non sans mal) d'un programme Blink.
- 19/03/2021 : Programmation de la clé via ICSP, réglage (non sans difficulté) des e-fusibles.
- 22/03/2021 : La ne communique a nouveau plus, puis remarche. Debut d'un programme de communication avec la mémoire
- 26/03/2021 : Soudage de la mémoire sur la deuxième clé, continuation du programme d'identification.
- 29/03/2021 : Création du code "final" de l'AtTiny, remplissage du wiki.
- 01/04/2021 : Finition définitive de la clé USB. Elle est maintenant capable de se téléporter dans la poche de l'espion. Poisson d'avril ! Finition de la mise a jour du wiki, et conception 3D du nouveau boitier.
- 05/04/2021 : Soudure des nouveaux interrupteurs. Programmation du code de l'AtTiny pour gérer les LEDs et une communication Série.
- 08/04/2021 : Code pour tester la communication avec la mémoire (Read ID) fait maison, sans succès.
- 12/04/2021 : Continuation du code de communication avec la mémoire, encore une fois sans succès. Adaptation du code de Albin pour parler avec la mémoire, toujours sans succès.
- 15/04/2021 : Finition du Wikipédia. Conclusion sur notre Bureau d'Etudes, recherche de piste de progression.
