Version du 2 avril 2020 à 16:10

Idée du projet

Lors de ce BE nous allons tenter de fabriquer une clé USB présentant une fonctionnalité inédite et originale. Nous allons utiliser une mémoire d'une capacité de 16Mo, ce qui nous intéresse le plus étant l'ajout d'une fonctionnalité amusante sur notre clé USB.

Tout le monde se trompe au moins deux fois de sens avant d'insérer une clé USB. Pour remédier à cela, nous allons développer une clé nous indiquant directement si elle est orientée correctement ou non. Pour se faire, elle vibrera tout simplement lorsqu'elle se trouve à l'envers. Afin de mettre cette idée en pratique, nous devrons donc ajouter un module supplémentaire composé d'un vibreur ainsi que d'un accéléromètre (un appareil détectant son accélération donc indirectement sa pesanteur, et ainsi sa position dans l'espace) et enfin d'une batterie alimentant le tout.

Néanmoins, plusieurs difficultés se posent. D'abord, les ordinateurs possèdent des ports USB pouvant se trouver dans n'importe quelle orientation. C'est pour ça que l'on se basera sur la majorité des ordinateurs qui possèdent en général des ports USB orientés de deux manières différentes (*ajouter image*)

Il faudra pour les cas ne respectant pas cette "généralité" la possibilité d'activer ou désactiver cette fonctionnalité, et donc ajouter un interrupteur. De plus, désactiver cette fonctionnalité dès l'instant ou la clé est branchée dans l'ordinateur semble également nécessaire en cas de bug ou de problème technique imprévu. Enfin ce module devra également se désactiver lorsque la clé ne sera pas utilisée pour ne pas user de batterie.

Réalisation du projet

Pour réaliser notre clé nous nous baserons donc sur le schéma électronique version béta de la carte à faible capacité (celui issu du fichier "cle_usbv2.fzz").

Les composants spécifiques que l'on utilisera sont un accéléromètre pour détecter la position de la clé dans l'espace, ainsi qu'un vibreur miniature. Ces deux composants seront le coeur du module "vibreur", même si d'autres composants s'ajouteront sans doute, tel qu'une batterie ou éventuellement des résistances.

Les modèles retenus pour ces deux composants sont le MMA1250KEG de NXP pour l'accéléromètre et le VM1201 pour le vibreur

 

Comme dit dans la présentation du projet, le module "vibreur" devra être ajouté à part. Tout d'abord pour éviter tout problème de casse éventuel et surtout car cela nous permettra de changer sa batterie sans risquer d'endommager la partie stockage.

Pour que le module s'active dans l'intervalle de temps juste avant qu'on branche la clé, un interrupteur pourrait suffire mais cela ne serait pas "pratique" à utiliser. Il semble plus judicieux dans une utilisation réaliste de la clé d'automatiser chaque activation/désactivation du module, c'est donc sans doute ici que se trouvera toute la difficulté de ce projet.

Les différents moments à prendre en compte sont :

• Quand la clé est inutilisée (dans la poche/posée sur une table), le module doit être éteint pour ne pas vibrer et gaspiller la batterie inutilement
• Quand on veut utiliser la clé, le module doit s'allumer à ce moment précis pour vérifier l'orientation.
• Dans le cas spécial où le port USB n'est pas dans une orientation habituelle, il faut désactiver le module pour pouvoir brancher la clé néanmoins.
• Enfin, quand la clé est branchée il ne faut pas qu'elle vibre dans le port USB, le module doit donc être désactivé.

Nos premières pistes pour gérer ces automatisations sont donc :

• Ajouter un système discret pour savoir quand la clé est utilisée et quand elle ne l'est pas, pour gérer l'état de la batterie. L'utilisation d'une clé à ouverture par "glissement" pourrait être intéressant pour se faire, en effet il suffirait de relier une batterie externe à notre module uniquement quand on ouvre mécaniquement la clé (*ajouter schéma*). Pour cela il faudra placer la dite batterie et le reste de la clé dans deux parties séparées qui ne se connecteront que quand la clé sera ouverte. (*ajouter schéma*)

• "Dériver" le courant circulant dans la clé vers notre module, pour éteindre complètement le module lorsque la clé est branchée (on utilisera alors un microcontrôleur qui en plus de gérer l'accéléromètre pourra prendre cette tension en compte dans ces calculs).

• Ajouter un bouton d'urgence sur lequel appuyer si on veut éteindre le module manuellement le temps de notre pression. On choisit de privilégier un bouton à un simple interrupteur car l'utilisation de celui-ci parait bien plus naturelle et simple quand on tient la clé entre nos doigts. (Ce bouton sera également pris en compte dans les calculs du microcontrôleur gérant le module).

Chronologie

27/01/2020 :

Recherche d'idées de fonctionnalités à ajouter sur la clé USB :

* Faire en sorte que la clé vibre quand on la tient dans le mauvais sens, afin de faciliter son utilisation (et bien sur pouvoir désactiver cette fonctionnalité via un interrupteur pour ne pas la faire vibrer dans la poche). 
On utilisera un accéléromètre pour détecter l'orientation de la clé.

* Pouvoir "bipper" la clé à distance avec une télécomande ou si possible un smartphone. On pourrait utiliser comme base nos travaux sur les émetteurs radio, mais la complexité pourrait nous faire perdre du temps. On garde donc cette 
idée en réserve si il nous reste du temps pour la réaliser.

10/02/2020 :

Recherche d'un accéléromètre qui conviendrait au projet, c'est à dire de taille convenable et donc soudable sans trop de difficultés, avec une gamme de mesures correspondant à l'utilisation qu'on en fera : détecter la gravité 
terrestre pour déterminer l'orientation de notre clé.

Le MMA1250KEG de NXP semiconductors se démarque des autres. Il mesure environ 10mm par 10mm, et ses broches sont bien apparentes sur les côtés, ce qui permettra une soudure facilitée. Enfin, il détecte jusque 5g ce qui est 
typiquement la marge que l'on souhaite. Son utilisation conseillée correspond à celle que l'on veut en faire.

Début des choix de design pour intégrer le "module vibreur" au sein de la clé de manière optimale (notamment allumer ce module UNIQUEMENT quand on veut utiliser la clé)

17/02/2020 :

Créer une clé USB semble assez complexe, il nous faut donc de l'entraînement avant de se lancer dans un tel projet.
C'est pour cette raison que nous allons nous lancer sur la production d'un dé électronique afin de mieux appréhender chaque étape de fabrication d'un système électronique.
Pour créer ce dé électronique, nous allons donc d'abord en réaliser le schéma électronique sur le logiciel Fritzing

Ce dé électronique sera donc composé entre autres d'un AtTiny84, de 7 résistances et de 7 LEDs, d'un bouton et enfin d'une batterie. 
Assez peu d'éléments en somme et surtout des éléments simple à implémenter pour s'entrainer.

02/03/2020 :

Suite de la réalisation du circuit électronique sur Fritzing avec le passage sur la version PCB de notre maquette.
Les connexions sont réalisées et validées, nous pouvons donc passer à l'impression du circuit sur une plaque de cuivre, il ne restera plus qu'à souder chaque composant nécessaire au dé puis à coder le programme.

05/03/2020 :

Notre circuit imprimé étant enfin prêt, il nous faut maintenant commencer les différentes soudures (ou plutôt les brasures) pour y mettre les éléments indispensables à la programmation de notre AtTiny84.
Nous avons donc soudé l'AtTiny84 ainsi que 2 résistances et 2 LEDs servant à tester le programme que l'on implantera plus tard.

09/03/2020 :

Nous avons presque terminé de souder les éléments nécessaires aux tests du dé, soit des fils soudés sur certaines pattes de l'AtTiny, le support de la batterie ainsi que le bouton.

12/03/2020 :

Maintenant que la première étape pour les soudures est terminée, il nous reste le programme du dé à faire afin de l'implanter sur l'AtTiny84. Une fois ceci fait, nous pourrons alors enlever les fils ajoutés sur ses pattes ainsi que 
de souder le reste des LEDs et resistances.

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);
 }

Projet d'initiation, dé électronique

La conception d'une clé USB étant complexe pour des débutants, nous avons commencé par fabriquer un Dé électronique afin de nous familiariser avec la construction d'un appareil électronique. Nous avons dans un premier temps en s'aidant d'une vidéo youtube, fait un schéma du Dé en utilisant le logiciel Fritzing. Cela nous a permis de voir et de comprendre comment une carte électronique était composé/fabriqué. Au niveau de la composition de notre dé, ce dernier a été composé avec 7 Leds, 7 résistances, un bouton, une batterie et un AtTiny84 comme on peut le voir sur la première image.

Schéma électronique du dé

Notre schéma étant terminé, nous avons fait une version PCB dans le but de "l'imprimer" et de souder les différents composants dessus (2ème image). Le fichier source Fritzing est disponible ici : media:DeLedB4.zip (pour l'ouvrir avec Fritzing il faut penser à changer l'extension .zip en .fzz)

Représentation PCB du dé

On va tout d'abord souder les LEDs pour tester si elles fonctionnent et si il n'y a pas de problèmes de microcontrolleur. Pour cela nos enseignants ont proposé ce code qui semble fonctionner dans un cadre de test des LEDs :

#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-4-test1.mp4.

Notre dé électronique ressemble donc à ceci :

Pour faire fonctionner le dé, il faut ensuite insérer un programme dans notre AtTiny84.

#define MAX_LED 7
int leds[]={5,4,1,3,6,2,0};
void setup() {
  int i;
  for(i=0;i<MAX_LED;i++) pinMode(leds[i], OUTPUT);
  pinMode(9, INPUT_PULLUP);
  randomSeed(analogRead(A7));
}

void allumer(int n)
{
  if n==1
  {
    digitalWrite(leds[3], HIGH);
  }
  else if n == 2
  {
    digitalWrite(leds[0], HIGH);
    digitalWrite(leds[6], HIGH);
  }
  else if n == 3
  {
    digitalWrite(leds[0], HIGH);
    digitalWrite(leds[6], HIGH);
    digitalWrite(leds[3], HIGH);
  }
  else if n == 4
  {
    digitalWrite(leds[2], HIGH);
    digitalWrite(leds[6], HIGH);
    digitalWrite(leds[0], HIGH);
    digitalWrite(leds[4], HIGH);
  }
  else if n == 5
  {
    digitalWrite(leds[2], HIGH);
    digitalWrite(leds[6], HIGH);
    digitalWrite(leds[0], HIGH);
    digitalWrite(leds[4], HIGH);
    digitalWrite(leds[3], HIGH);
  }
  else if n == 6
  {
    digitalWrite(leds[2], HIGH);
    digitalWrite(leds[1], HIGH);
    digitalWrite(leds[0], HIGH);
    digitalWrite(leds[6], HIGH);
    digitalWrite(leds[5], HIGH);
    digitalWrite(leds[4], HIGH);
  }
  
}

void eteindre()
{
  int i
  for (i=0;i<MAX_LED;i++)
  {
    digitalWrite(leds[i],LOW);
  }
}

void loop() {
  int i,n;
  if digitalRead(9) == LOW
  {
    n = random(1,7);
    allumer(n);
    delay(1000); 
  }
  eteindre();

}

Une fois ce programme inséré, le dé est donc fonctionnel. Voici donc la vidéo de la démonstration finale :

media:video_de4.mp4