Version actuelle datée du 19 avril 2021 à 10:49

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 ?)

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.

Verso PCB

Recto PCB

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é)

Verso PCB

Add On

Recto PCB

Main

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 :

Les images sont mal dimensionnées, mais nous avons un problème avec le redimensionnement via le Wiki.

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;//definition des pins
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");//Recoit le remplissage de la carte
  }
  remp = data.toInt();
  led(remp);

  if (digitalRead(btn) == HIGH){//Envoi un message à l'AtMega et fade la Led
    mySerial.write("R");
    for (int i =100; i<1; i--){
      led(i);
      delay(10);
    }
  }
}

void led(int remplissage){//remplissage en pourcent
  //allume les leds +/- fort en fonction de la valeur passée en paramètre
  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 :

Téléversement

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.

Boitier Clé USB

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 :

Boitier Clé USB

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 : Structuration du Wikipédia. Conclusion sur notre Bureau d'Etudes, recherche de piste de progression.
19/04/2021 : Finition du Wikipédia.

Binome2020-12 : Différence entre versions