Version actuelle datée du 23 mai 2020 à 15:01

INTRODUCTION

Description du projet

Le but de notre Bureau d'Étude est de créer notre propre clé USB (Universal Serial Bus) de 16 Go, comprenant la réalisation des logiciels, la fabrication de la clé et l'ajout de fonction(s) supplémentaire(s). La difficulté première est que la création de ce type de clé est encore expérimentale.

De notre côté, nous avons choisi de nous attaquer au verrouillage de la clé, et ce par code à deux chiffres, potentiellement grâce à deux compteurs molette (comme suit). Le but de ce verrouillage sera de sécuriser au maximum les données personnelles et professionnelles présentes dans la clé.

Matériel utilisé

Carte électronique à utiliser

Molettes potentiomètre à 10 chiffres utilisées sur la clé

Cette molette possède trois pattes : La première (+) et la troisième (-) sont les pattes d'alimentation et la deuxième est la patte de sortie du courant. Ici, les différentes valeurs affichées représentent le palier de courant envoyé. Le but serait de faire reconnaître ces paliers en tant que nombre afin de les utiliser comme élément d'un code.Seulement, elle nécessite une prise analogique sur le micro-contrôleur. Nous allons donc utiliser un ATMEGA32U4 que l'on modifiera afin d'être adapté au projet. Il analysera les tensions renvoyées par le potentiomètre, comparera celles-ci aux valeurs choisies pour le code et permettra ou non la lecture et l'écriture dans la clé.

Carte Arduino UNO à programmer

Logiciel Arduino servant à coder

Afin de programmer notre clé, nous utiliserons le logiciel Arduino, branché à un Arduino UNO.

Projet intermédiaire : Dé

Afin de de se familiariser avec l'environnement et les outils dont nous auront besoin pour la réalisation de notre clé USB, nous avons réalisé un premier projet plus simple : un carte électronique composés de 7 leds afin de représenter un lancé de dé. Lors de la pression sur le bouton de la carte, les leds doivent s'allumer de manière à représenter un chiffre aléatoire tel qu'il est sur un dé.

De fini

Réalisation

Tout d'abord, nous avons réalisé le PCB de la carte sur le logiciel Fritzing afin de pouvoir ensuite l'imprimer. Tout d'abord nous avons réaliser le schéma électrique de la carte : microcontrôleur (attiny84), bouton, alimentation (batterie), 7 resistances, 7 leds. Une fois les composants mis en place et relié entre eux, nous avons réalisé le PCB de la carte en veillant à ce que les pistes ne se croisent pas et à ce que tous les composants soient bien placé. En parallèle de cette étape, nous avons conçu le programme permettant l'affichage sur les leds.

Une fois la carte imprimée, nous avons soudé les différents composants dessus puis testé le programme.

Voici le fichier Fritzing : Fichier:Circuit de.zip

Schéma circuit

Pcb circuit

Programme

Nous avons tout d'abord fait un programme fonctionnant sur un arduino UNO pour ensuite le modifier facilement afin qu'il fonctionne sur la carte du dé. Afin de générer un nombre aléatoire nous utilisons la fonction random ainsi que la fonction randomSeed pour que la séquence de nombre soit différente à chaque démarrage de la carte. Nous avons aussi mis en place une animation qui se joue à chaque pression du bouton représentant un lancé de dé. Le nombre est ensuite affiché sur les leds à la manière d'un dé classique.

Voici une vidéo du fonctionnement du dé sur l'arduino : Fichier:Arduino de.mp4

Voici le programme :

 int pin[7]={5,4,1,3,6,2,0}, pinButton = 9;
 int randNum=1, i;
 
 void setup() { 
   Serial.begin(9600);  
   randomSeed(analogRead(A7));
   for(i=0; i<7; i++){
     pinMode(pin[i], OUTPUT);
   }
   pinMode(pinButton, INPUT_PULLUP);
 }
 
 void afficheNum(int nbr) {
   if(nbr == 1){
     digitalWrite(pin[3], HIGH);
   }
   if(nbr == 2){
     digitalWrite(pin[0], HIGH);
     digitalWrite(pin[6], HIGH);
   }
   if(nbr == 3){
     digitalWrite(pin[0], HIGH);
     digitalWrite(pin[3], HIGH);
     digitalWrite(pin[6], HIGH);
   }
   if(nbr == 4){
     digitalWrite(pin[0], HIGH);
     digitalWrite(pin[2], HIGH);
     digitalWrite(pin[4], HIGH);
     digitalWrite(pin[6], HIGH);
   }
   if(nbr == 5){
     digitalWrite(pin[0], HIGH);
     digitalWrite(pin[2], HIGH);
     digitalWrite(pin[3], HIGH);
     digitalWrite(pin[4], HIGH);
     digitalWrite(pin[6], HIGH);
   }
   if(nbr == 6){
     digitalWrite(pin[0], HIGH);
     digitalWrite(pin[1], HIGH);
     digitalWrite(pin[2], HIGH);
     digitalWrite(pin[4], HIGH);
     digitalWrite(pin[5], HIGH);
     digitalWrite(pin[6], HIGH);
   }
 }
 
 int vitesse = 60, nbrTour = 4;
 void animation(){
   for(i=0;i<nbrTour;i++){
     digitalWrite(pin[0], HIGH);
     delay(vitesse);
     digitalWrite(pin[0], LOW);
     digitalWrite(pin[1], HIGH);
     delay(vitesse);
     digitalWrite(pin[1], LOW);
     digitalWrite(pin[2], HIGH);
     delay(vitesse);
     digitalWrite(pin[2], LOW);
     digitalWrite(pin[6], HIGH);
     delay(vitesse);
     digitalWrite(pin[6], LOW);
     digitalWrite(pin[5], HIGH);
     delay(vitesse);
     digitalWrite(pin[5], LOW);
     digitalWrite(pin[4], HIGH);
     delay(vitesse);
     digitalWrite(pin[4], LOW);
   }
 }
 
 void loop() {
   if(digitalRead(pinButton)==0){
     
     //On enleve l'affichage
     for(i=0; i<7; i++){
       digitalWrite(pin[i], LOW);
     }
     animation();
     randNum = random(1, 7);
     afficheNum(randNum);
     delay(1000);
   }
 }

Réalisation de la clé

Fonctionnement

La spécificité de notre clé est d'être déverrouillée à l'aide d'un code qui sera entré par l'utilisateur à l'aide d'une molette et d'un bouton. Cette molette n'est quand fait un potentiomètre rotatif auquel on associe à chaque valeur une plage de tension transmise pour obtenir le chiffre saisie. On utilise un aussi un bouton afin de valider la saisie d'un chiffre. Si la séquence de chiffre est correcte, la led clignote 3 fois puis reste allumer la clé est alors déverrouillée. En revanche, si la séquence de chiffre est incorrecte, la led clignote 3 fois puis s'éteint pour signaler que la clé est toujours verrouillée, l'utilisateur peut alors à nouveau entrer un code.

Matériel

En plus de la clé USB de base, le système de verrouillage que nous ajoutons nécessite du matériel supplémentaire :

- Une molette permettant de sélectionner un chiffre du code. Cette molette est un potentiomètre sur lequel on fixe une roue avec des chiffes. Trouver un composant de ce type sur Web relève de l'impossible, c'est pourquoi nous pensions utiliser un potentiomètre classique auquel on ajoute une roue imprimé en 3D dessus.

Exemple de molette potentiomètre à 10 chiffres

potentiometre utilisé

- Un bouton permettant de valider la sélection du nombre avec la molette.

- Une Led afin de signaler à l'utilisateur si le code est valide ou non.

Conception

Voici le schématique de notre clé comprenant cinq parties : alimentation, USB, micro-contrôleur, mémoire et verrouillage. Ce dernier est la fonction supplémentaire que nous avons décidé d'implanter à notre clé. On a donc utilisé un potentiomètre afin de choisir la tension que l'on envoie au pin PD7 du micro-contrôleur. Il permettra d'entrer le "mot de passe", sélectionné au préalable. Suite à cette sélection, une simple pression du bouton permettra la validation de celle-ci. Puis si le code est bon, la LED s'allume puis le reste. Au contraire, s'il est faux, elle s'allume puis s'éteint.

Programme

Voici un premier jet de la fonction permettant de déverrouiller la clé. Pour le moment la fonction est codé en Arduino (c++), il nous faut la traduire en c afin de l'implémenter dans le programme de la clé.

 void verrou() {
   int code[] = {1,2,3}, seq[3];
   int i;
   
   do {
     digitalWrite(led,LOW);
     for(int i;i<3;i++){
       while(digitalRead(button)!=0){
         seq[i]=map(analogRead(pot),0,1023,0,9);
         digitalWrite(led,HIGH);
         delay(300);
         digitalWrite(led,LOW);
       }
     }
     digitalWrite(led,HIGH);
     delay(300);
     digitalWrite(led,LOW);
     delay(300);
     digitalWrite(led,HIGH);
   }while(seq[0]==code[0] && seq[1]==code[1] && seq[2]==code[2]);
 }

Nous avons ensuite tenté de convertir cette fonction afin de pouvoir l'incorporer dans le programme de la clé. Nous avons aussi recréer et modifier la fonction map afin qu'elle corresponde mieux à nos besoin. Nous n'avons que très peu de connaissances avec ce type de programmation et nous nous sommes inspirés de programme de test pour créer ces fonction.

unsigned char ledVerrou[]={0x00,0x10,0x00};
unsigned char button[]={0x00,0x20,0x00};
unsigned char pot[]={0x00,0x00,0x80};

#define MAX_LED		1

#define LED		0

int mapPotentiometre(int value, int fromLow, int fromHigh, int toLow, int toHigh){
 int div = fromHigh/toHigh, chiffre;
 while(value>div){
  chiffre++;
  div+=div;
 }
 return chiffre;
}

outputs_init(ledVerrou);
input_init(button);
input_init(pot);

void verrou() {
 //code = 123
 int code[] = {1,2,3}, seq[3];
 int i;
 do {
  output_unset(led, LED); _delay_ms(100);
  //code a 3 chiffres
  for(int i;i<3;i++){
   while(input_get(button)!=0){
    seq[i]=mapPotentiometre(input_get(pot),0,1023,0,9);
    output_set(led, LED);
    _delay_ms(300);
    output_unset(led, LED);
   }
  }
  output_set(led, LED); _delay_ms(300);
  output_unset(led, LED); _delay_ms(300);
  output_set(led, LED); _delay_ms(300);
 }while(seq[0]==code[0] && seq[1]==code[1] && seq[2]==code[2]);
}

Déroulement des séances

- 27/01 et 10/02 : Nous avons recherché et précisé le choix de la molette pour le verrouillage de notre clé, en avons discuté avec les professeurs afin d'en comprendre le "branchement". L'idée principale sera de fixer de fixer les différentes pattes de cette molette sur les ports inutilisés du microcontrôleur et d'en établir les liens.

- 17/02 : Nous avons commencer la prise en main d'un logiciel (FRITZING) pour la mise en place des éléments à incorporer sur la carte, à travers un exemple : un dé électronique. Nous avons pu expérimenter la schématisation, le routage et l'organisation de ces différents éléments sur la carte.

(https://www.youtube.com/watch?v=jvw5OCUHaqc&t=72s)

- 20/02 : Pas cours.

- 02/03 : Nous avons continué la conception du dé électronique, en cherchant à optimiser l'espace pour les composants et leurs connections, et commencé à nous renseigner sur le codage de celui-ci. (Programmation d'un Arduino UNO[1])

- 05/03 : Nous avons finalisé le modèle du dé électronique sur Fitzing, et envoyé le modèle à imprimer.

- 09/03 : Nous avons reçu la carte de notre dé et fait la programmation de celui-ci. L'idée était de faire un remplissage des LEDs qui, par la suite, sera modifié pour être de la même forme que sur un dé (c'est-à-dire un H). Seulement, celui-ci se devait d'être aléatoire. Nous avons donc utilisé des fonctions comme random(x,y) (x=minimum et y=maximum). Pour le bouton, nous avons fait en sorte qu'un courant soit toujours envoyé, puis, à l'aide d'un fil représentant l'interrupteur, le courant était coupé. Cette coupure étant détectée, nous nous en sommes servi. Enfin, nous avons testé sur l'Arduino UNO.

Carte semi soudée du dé

- 12/03 : Nous avons commencé le soudage sur la carte des différents éléments du dé : 7 LEDs, 7 résistances, un bouton, une batterie et un micro-contrôleur.

- 16/03 : Première séance à distance par chat. Malheureusement en retard, nous avons pris soin de noter les différentes remarques du professeurs à l'encontre des autres groupes afin d'éviter tous problèmes concernant le code. Nous avons continué le code du dé puis commencé le PCB de la clé USB. Tristan s'occupera du code tandis que Gaëtan s'occupera du schéma et de la mise en place sur la carte.

- 19/03 : Le programme du dé est terminé fonctionne sur l'arduino Uno et a été envoyé aux professeurs afin de le tester sur la carte. Nous avons modifié la définition des pins dans le programme afin qu'ils correspondent à ceux de L'attiny84. Nous avons aussi ajouter une animation lorsque l'on appuie sur le bouton afin de représenter le roulement du dé.

- 23/03 : Le programme est testé sur la carte et est fonctionnel après quelques modifications.

- 26/03-07/05 : Consultation du BE à travers un chat (https://chat.plil.fr/peip/channels/bureau-etudes-ima-sujet-6) et télé-travail avec le binôme: conception du PCB de la clé, résolution de problèmes techniques, réalisation du code d'abord en Arduino puis retranscrit en C. Consultation avec les professeurs concernant des précisions sur le code et le schématique de la carte. Finition du code et vérification du PCB par les professeurs. Mise à jour du Wiki. Bilan final.