Version du 20 mai 2020 à 16:29

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

En effet, l'accéléromètre MMA1250KEG détecte l'accélération qu'on lui impose, et donc quand il est dans un état "stable", peut détecter l'accélération gravitationnelle de la Terre.
Autrement dit, il servira à détecter si la clé est dans un sens ou dans un autre. Pour se faire, il envoie une tension de sortie de 2.5V lorsqu'il est à l'endroit, et de -2.5V quand il est à l'envers.
Le microcontrôleur intégré à la clé pourra ainsi facilement déduire de ces changements de tension l'orientation de la clé.

Accéléromètre MMA1250KEG

Vibreur miniature VM1201

Le vibreur VM1201 quant à lui est le vibreur le plus petit et discret que nous avons trouvé à bon prix, il remplira parfaitement sa seule fonction : vibrer. De plus, le fait qu'il soit filaire nous permettra de le séparer de la carte 
électronique et de le fixer facilement dans la coque de la clé avec de l'adhésif par exemple

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 interrupteur pour éteindre/allumer la batterie quand il le faut

• "Dériver" le courant circulant dans la clé vers notre module, pour éteindre complètement le module lorsque la clé est branchée

• Ajouter un bouton sur lequel appuyer pour activer la détection. Ainsi, on aura qu'à appuyer dessus pour savoir si la clé est bien orientée ou non. 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).

Conception de la clé

On commence la conception de la clé par son schéma électronique sur le logiciel Fritzing. Pour se faire on utilisera comme base la clé développée par nos enseignants (disponible ici media:cle_usbv2.zip ). On va maintenant apporter les modifications et ajouts nécessaires pour avoir un système qui répond à nos attentes

Tout d'abord, si on veut que notre système fonctionne sur batterie, il faut remplacer l'alimentation du micro-contrôleur. On place donc notre batterie et notre interrupteur en série, comme prévu, puis on les connecte aux ports d'alimentation de l'ATmega8U2 (le micro-contrôleur gérant toute la clé USB)

 
On a ajouté un condensateur de découplage sur la broche VCC de notre micro-contrôleur afin de réduire au maximum les perturbations dans le courant.

Maintenant que notre clé est alimentée par une batterie et non plus par le périphérique auquel elle est branchée, on peut ajouter les composants manquants : un bouton, un accéléromètre et un vibreur Le schéma électronique de notre clé est donc terminé

Il faut également agrandir le PCB, pour cela on utilise le logiciel InkScape et on créé une forme personnalisée (dans notre cas la même forme que la clé de base mais allongée pour mettre plus de composants dessus). Le dessin fait sur Inkscape doit respecter plusieurs critères : il doit être composé de 2 calques, le "silkscreen" et le "board". Ceux-ci doivent respecter des dimensions précises et doivent avoir une id (identificateur)que Fritzing pourra reconnaître. Ces modifications se font facilement dans les différents paramètres de InkScape et nous permettent d'avoir ce nouveau PCB :

Dessin du PCB réalisé sur Inkscape

Cette image est ce qu'on appelle une image vectorielle, elle est définie non pas par ses pixels directement mais principalement par les vecteurs composant ses formes. Ainsi ce format permet une plus grande précision et ne permet 
théoriquement pas la perte de résolution de l'image lorsqu'on l'agrandit, ce qui est parfait pour l'utilisation sur Fritzing notamment.

On peut maintenant remplacer la forme par défaut avec la notre dans Fritzing. Une fois le routage terminé, le résultat est le suivant :

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

19/03/2020 :

Mise à jour du wiki avec les rubriques du travail pour l'instant fait (concept de la clé explicité et travail sur le dé réalisé avant le confinement)

23/03/2020 :

Le programme fait pour le dé étant resté sur les ordinateurs de Polytech, nous devons donc le retravailler de zéro.

26/03/2020 :

Réglage de soucis de dernière minute sur le programme du dé, notamment sur le manque d'aléatoire. Il suffit finalement d'ajouter la commande RandomSeed dans l'initialisation. Nous en profitons également pour terminer la partie du wiki portant sur le dé

30/03/2020 :

Discussion sur la mise en oeuvre de notre idée de clés, notamment sur les paramètres qui seraient intéressants à traiter sur notre clé.

02/04/2020 :

Après avoir choisi la marche à suivre et discuté des solutions à mettre en oeuvre, nous recherchons alors les meilleurs composants pour réaliser cette tache. L'accéléromètre étant déjà choisi, on trouve également un vibreur et un microcontrôleur convenables. Il ne nous reste qu'à étudier leurs fiches techniques pour créer le schéma de notre "module vibreur"

06/04/2020 :

Début du travail sur Fritzing, on part du schéma de la clé v2 donnée par nos professeurs sur le wiki et on créé les composants personnalisés correspondant à ceux que l'on souhaite ajouter. On étudie également la manière dont le schéma de la clé est fait pour comprendre ce qu'on peut faire pour réaliser le reste du schéma.

09/04/2020 :

Suite du travail sur Fritzing où on tente toujours de comprendre comment réaliser les liaisons entre nos différents composants, notamment notre nouveau micro-contrôleur et notre accéleromètre. En parallèle, les premières ébauches du programme gérant notre module vibreur sont créées pour savoir ou on se dirige.

27/04/2020 :

Une première ébauche du schéma Fritzing a été faite, cependant il est possible de tout faire tenir sur un seul micro-contrôleur, pas besoin donc d'en ajouter à priori. Il faudra donc retravailler sur une toute nouvelle version du schéma électronique, mais le travail fait jusqu'ici nous facilitera la tâche car on sait maintenant comment réaliser les branchements de l'accéleromètre. Il nous faudra donc apporter des modifications au niveau de l'alimentation de la clé qui se fera par batterie et plus par branchement sur un appareil, le module étant censé fonctionner sans être branché.

30/04/2020

Le schéma a été modifié afin de faire tenir tout le système sur un seul micro-contrôleur. On a notamment modifié l'alimentation de ce dernier pour le faire dépendre d'une batterie et non plus du périphérique auquel il est branché. On peut maintenant passer à la partie PCB

04/05/2020

Passage à la partie PCB, petite difficulté dans l'utilisation de Fritzing car l'application semble être très lente et "crashe" souvent.

07/05/2020

Finir le PCB de la carte nécessite de modifier la forme de celui-ci : en effet, il faut plus de place pour ajouter les éléments supplémentaires tel que l'accéléromètre, la batterie, etc... Pendant qu'un des élèves continue de travailler sur le PCB, l'autre essaye donc de personnaliser la forme de ce dernier, en utilisant le logiciel Inkscape pour créer une image vectorielle (au format .vsg)

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