troyesGEII - Contributions de l’utilisateur [fr]

CleUSB

2016-04-23T16:36:44Z

Cleusb : /* {{Bleu|Conception de la deuxième carte}} */

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser, dans un premier temps, une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra également permettre stocker et saisir des mots de passes. Pour cela nous avons réalisé successivement plusieurs clés, la première servant uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Etant donné que nous devons utiliser le port USB comme liaison série et comme clavier virtuel, nous avons basé notre projet sur un microcontrôleur ATMEGA32U4 car les deux fonction sont intégrées dans celui-ci. Nous avons donc repris le schéma de l'ARDUINO LEONARDO qui utilise un ATMEGA32U4, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation externe et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des signaux et des mesures. 
Nous avons ajouté 4 boutons et 4 LEDs sur le port D maintenant inutilisé. 
Dans cette première version, nous avons conservé par sécurité un connecteur ISP pour la programmation, mais l'objectif est de se passer de l'ISP et de programmer la carte par USB.

Voici la première version de la clé USB:

[[Image:USB1-photo.jpg|vignette|left|upright=1.5]]
[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous avons installé un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation ZIF et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé le boitier d'adaptation à notre disposition, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous avons donc créé une nouvelle carte d'adaptation sur laquelle souder le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de Remote_ au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous avons également réalisé une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprime donc le connecteur utilisé dans la précédente clé. Le connecteur ISP est également supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour certaines résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage. 
Nous avons ajouté des morceaux de clinquant sur les connecteurs USB affin de corriger une erreur de dimensionnement de celle-ci et d'augmenter l'épaisseur du connecteur. En effet, le PCB est trop fin donc dans certain ports USB trop larges, il n'y a pas de contact entre les connecteur mâle et femelle.

[[Image:USB2-photo.jpg|vignette|upright=3|left]]
[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


={{Rouge|Gestion de mot de passe}}=

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

=={{Bleu|Protocole de communication}}==
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

=={{Bleu|Fonctionnement du microcontrôleur}}==
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensibles lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

=={{Bleu|Interface graphique}}==
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlP5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{|
|-
|[[Image:GUI-etape1.png|vignette|left|upright=1.5|1ère étape: choix de l'identifiant à modifier]]||
[[Image:GUI-etape2.png|vignette|left|upright=1.5|2ème étape: modification du mot de passe et de l'identifiant]]
|}

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mots de passes
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décalage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interruption déclenchée lors de la sélection d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interruption déclenchée lors de l'appui sur le bouton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //après 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //après 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (vias plus espacés), et d'inclure un anneau pour fixer un porte clé. Nous avons également modifié le composant du connecteur USB afin d'ajouter une surface métallique au dos du connecteur pour souder une plaque de clinquant.

[[Image:USB3-photo.jpg|vignette|left|upright=1.5]]
{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB. Ce boitier a été réalisé par impression 3D. 
Voici les dimensions des deux éléments du boitier ainsi qu'un aperçu du résultat :
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|-
| [[Image:USB-boitier.jpg|vignette|center|upright=1.5|Boitier imprimés]] ||[[Image:Clé_USB_HARENDARZ.jpg|vignette|center|upright=1.5|3ème clé et boitier]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clés (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

CleUSB

2016-04-23T16:35:08Z

Cleusb : /* {{Bleu|Conception de la deuxième carte}} */

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser, dans un premier temps, une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra également permettre stocker et saisir des mots de passes. Pour cela nous avons réalisé successivement plusieurs clés, la première servant uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Etant donné que nous devons utiliser le port USB comme liaison série et comme clavier virtuel, nous avons basé notre projet sur un microcontrôleur ATMEGA32U4 car les deux fonction sont intégrées dans celui-ci. Nous avons donc repris le schéma de l'ARDUINO LEONARDO qui utilise un ATMEGA32U4, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation externe et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des signaux et des mesures. 
Nous avons ajouté 4 boutons et 4 LEDs sur le port D maintenant inutilisé. 
Dans cette première version, nous avons conservé par sécurité un connecteur ISP pour la programmation, mais l'objectif est de se passer de l'ISP et de programmer la carte par USB.

Voici la première version de la clé USB:

[[Image:USB1-photo.jpg|vignette|left|upright=1.5]]
[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous avons installé un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation ZIF et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé le boitier d'adaptation à notre disposition, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous avons donc créé une nouvelle carte d'adaptation sur laquelle souder le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de Remote_ au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous avons également réalisé une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprime donc le connecteur utilisé dans la précédente clé. Le connecteur ISP est également supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour certaines résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage. 
Nous avons ajouté des morceaux de clinquant sur les connecteurs USB affin de corriger une erreur de dimensionnement de celle-ci et d'augmenter l'épaisseur du connecteur. En effet, le PCB est trop fin donc dans certain ports USB trop larges, il n'y a pas de contact entre les connecteur mâle et femelle.

[[Image:USB2-photo.jpg|vignette|upright=3|left]]
[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


={{Rouge|Gestion de mot de passe}}=

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

=={{Bleu|Protocole de communication}}==
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

=={{Bleu|Fonctionnement du microcontrôleur}}==
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensibles lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

=={{Bleu|Interface graphique}}==
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlP5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{|
|-
|[[Image:GUI-etape1.png|vignette|left|upright=1.5|1ère étape: choix de l'identifiant à modifier]]||
[[Image:GUI-etape2.png|vignette|left|upright=1.5|2ème étape: modification du mot de passe et de l'identifiant]]
|}

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mots de passes
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décalage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interruption déclenchée lors de la sélection d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interruption déclenchée lors de l'appui sur le bouton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //après 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //après 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (vias plus espacés), et d'inclure un anneau pour fixer un porte clé. Nous avons également modifié le composant du connecteur USB afin d'ajouter une surface métallique au dos du connecteur pour souder une plaque de clinquant.

[[Image:USB3-photo.jpg|vignette|left|upright=1.5]]
{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB. Ce boitier a été réalisé par impression 3D. 
Voici les dimensions des deux éléments du boitier ainsi qu'un aperçu du résultat :
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|-
| [[Image:USB-boitier.jpg|vignette|center|upright=1.5|Boitier imprimés]] ||[[Image:Clé_USB_HARENDARZ.jpg|vignette|center|upright=1.5|3ème clé et boitier]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clés (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

CleUSB

2016-04-23T16:34:38Z

Cleusb : /* {{Bleu|Conception de la troisième carte}} */

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser, dans un premier temps, une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra également permettre stocker et saisir des mots de passes. Pour cela nous avons réalisé successivement plusieurs clés, la première servant uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Etant donné que nous devons utiliser le port USB comme liaison série et comme clavier virtuel, nous avons basé notre projet sur un microcontrôleur ATMEGA32U4 car les deux fonction sont intégrées dans celui-ci. Nous avons donc repris le schéma de l'ARDUINO LEONARDO qui utilise un ATMEGA32U4, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation externe et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des signaux et des mesures. 
Nous avons ajouté 4 boutons et 4 LEDs sur le port D maintenant inutilisé. 
Dans cette première version, nous avons conservé par sécurité un connecteur ISP pour la programmation, mais l'objectif est de se passer de l'ISP et de programmer la carte par USB.

Voici la première version de la clé USB:

[[Image:USB1-photo.jpg|vignette|left|upright=1.5]]
[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous avons installé un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation ZIF et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé le boitier d'adaptation à notre disposition, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous avons donc créé une nouvelle carte d'adaptation sur laquelle souder le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de Remote_ au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous avons également réalisé une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprime donc le connecteur utilisé dans la précédente clé. Le connecteur ISP est également supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour certaines résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage. 
Nous avons ajouté des morceaux de clinquant sur les connecteurs USB affin de corriger une erreur de dimensionnement de celle-ci et d'augmenter l'épaisseur du connecteur. En effet, le PCB est trop fin donc dans certain ports USB trop larges, il n'y a pas de contact entre les connecteur mâle et femelle.

[[Image:USB2-photo.jpg|vignette|upright=3|left|Schéma]]
[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


={{Rouge|Gestion de mot de passe}}=

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

=={{Bleu|Protocole de communication}}==
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

=={{Bleu|Fonctionnement du microcontrôleur}}==
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensibles lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

=={{Bleu|Interface graphique}}==
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlP5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{|
|-
|[[Image:GUI-etape1.png|vignette|left|upright=1.5|1ère étape: choix de l'identifiant à modifier]]||
[[Image:GUI-etape2.png|vignette|left|upright=1.5|2ème étape: modification du mot de passe et de l'identifiant]]
|}

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mots de passes
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décalage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interruption déclenchée lors de la sélection d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interruption déclenchée lors de l'appui sur le bouton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //après 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //après 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (vias plus espacés), et d'inclure un anneau pour fixer un porte clé. Nous avons également modifié le composant du connecteur USB afin d'ajouter une surface métallique au dos du connecteur pour souder une plaque de clinquant.

[[Image:USB3-photo.jpg|vignette|left|upright=1.5]]
{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB. Ce boitier a été réalisé par impression 3D. 
Voici les dimensions des deux éléments du boitier ainsi qu'un aperçu du résultat :
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|-
| [[Image:USB-boitier.jpg|vignette|center|upright=1.5|Boitier imprimés]] ||[[Image:Clé_USB_HARENDARZ.jpg|vignette|center|upright=1.5|3ème clé et boitier]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clés (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

Fichier:USB3-photo.jpg

2016-04-23T16:33:50Z

Cleusb :

CleUSB

2016-04-23T16:31:24Z

Cleusb : /* {{Bleu|Conception d'un boitier pour la clé}} */

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser, dans un premier temps, une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra également permettre stocker et saisir des mots de passes. Pour cela nous avons réalisé successivement plusieurs clés, la première servant uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Etant donné que nous devons utiliser le port USB comme liaison série et comme clavier virtuel, nous avons basé notre projet sur un microcontrôleur ATMEGA32U4 car les deux fonction sont intégrées dans celui-ci. Nous avons donc repris le schéma de l'ARDUINO LEONARDO qui utilise un ATMEGA32U4, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation externe et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des signaux et des mesures. 
Nous avons ajouté 4 boutons et 4 LEDs sur le port D maintenant inutilisé. 
Dans cette première version, nous avons conservé par sécurité un connecteur ISP pour la programmation, mais l'objectif est de se passer de l'ISP et de programmer la carte par USB.

Voici la première version de la clé USB:

[[Image:USB1-photo.jpg|vignette|left|upright=1.5]]
[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous avons installé un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation ZIF et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé le boitier d'adaptation à notre disposition, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous avons donc créé une nouvelle carte d'adaptation sur laquelle souder le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de Remote_ au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous avons également réalisé une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprime donc le connecteur utilisé dans la précédente clé. Le connecteur ISP est également supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour certaines résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage. 
Nous avons ajouté des morceaux de clinquant sur les connecteurs USB affin de corriger une erreur de dimensionnement de celle-ci et d'augmenter l'épaisseur du connecteur. En effet, le PCB est trop fin donc dans certain ports USB trop larges, il n'y a pas de contact entre les connecteur mâle et femelle.

[[Image:USB2-photo.jpg|vignette|upright=3|left|Schéma]]
[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


={{Rouge|Gestion de mot de passe}}=

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

=={{Bleu|Protocole de communication}}==
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

=={{Bleu|Fonctionnement du microcontrôleur}}==
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensibles lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

=={{Bleu|Interface graphique}}==
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlP5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{|
|-
|[[Image:GUI-etape1.png|vignette|left|upright=1.5|1ère étape: choix de l'identifiant à modifier]]||
[[Image:GUI-etape2.png|vignette|left|upright=1.5|2ème étape: modification du mot de passe et de l'identifiant]]
|}

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mots de passes
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décalage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interruption déclenchée lors de la sélection d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interruption déclenchée lors de l'appui sur le bouton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //après 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //après 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (vias plus espacés), et d'inclure un anneau pour fixer un porte clé. Nous avons également modifié le composant du connecteur USB afin d'ajouter une surface métallique au dos du connecteur pour souder une plaque de clinquant.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB. Ce boitier a été réalisé par impression 3D. 
Voici les dimensions des deux éléments du boitier ainsi qu'un aperçu du résultat :
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|-
| [[Image:USB-boitier.jpg|vignette|center|upright=1.5|Boitier imprimés]] ||[[Image:Clé_USB_HARENDARZ.jpg|vignette|center|upright=1.5|3ème clé et boitier]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clés (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

CleUSB

2016-04-23T16:29:13Z

Cleusb : /* {{Bleu|Correction}} */

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser, dans un premier temps, une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra également permettre stocker et saisir des mots de passes. Pour cela nous avons réalisé successivement plusieurs clés, la première servant uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Etant donné que nous devons utiliser le port USB comme liaison série et comme clavier virtuel, nous avons basé notre projet sur un microcontrôleur ATMEGA32U4 car les deux fonction sont intégrées dans celui-ci. Nous avons donc repris le schéma de l'ARDUINO LEONARDO qui utilise un ATMEGA32U4, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation externe et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des signaux et des mesures. 
Nous avons ajouté 4 boutons et 4 LEDs sur le port D maintenant inutilisé. 
Dans cette première version, nous avons conservé par sécurité un connecteur ISP pour la programmation, mais l'objectif est de se passer de l'ISP et de programmer la carte par USB.

Voici la première version de la clé USB:

[[Image:USB1-photo.jpg|vignette|left|upright=1.5]]
[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous avons installé un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation ZIF et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé le boitier d'adaptation à notre disposition, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous avons donc créé une nouvelle carte d'adaptation sur laquelle souder le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de Remote_ au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous avons également réalisé une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprime donc le connecteur utilisé dans la précédente clé. Le connecteur ISP est également supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour certaines résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage. 
Nous avons ajouté des morceaux de clinquant sur les connecteurs USB affin de corriger une erreur de dimensionnement de celle-ci et d'augmenter l'épaisseur du connecteur. En effet, le PCB est trop fin donc dans certain ports USB trop larges, il n'y a pas de contact entre les connecteur mâle et femelle.

[[Image:USB2-photo.jpg|vignette|upright=3|left|Schéma]]
[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


={{Rouge|Gestion de mot de passe}}=

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

=={{Bleu|Protocole de communication}}==
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

=={{Bleu|Fonctionnement du microcontrôleur}}==
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensibles lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

=={{Bleu|Interface graphique}}==
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlP5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{|
|-
|[[Image:GUI-etape1.png|vignette|left|upright=1.5|1ère étape: choix de l'identifiant à modifier]]||
[[Image:GUI-etape2.png|vignette|left|upright=1.5|2ème étape: modification du mot de passe et de l'identifiant]]
|}

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mots de passes
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décalage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interruption déclenchée lors de la sélection d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interruption déclenchée lors de l'appui sur le bouton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //après 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //après 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (vias plus espacés), et d'inclure un anneau pour fixer un porte clé. Nous avons également modifié le composant du connecteur USB afin d'ajouter une surface métallique au dos du connecteur pour souder une plaque de clinquant.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB. Ce boitier a été réalisé par impression 3D. 
Voici les dimensions des deux éléments du boitier ainsi qu'un aperçu du résultat :
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|-
| [[Image:USB-boitier.jpg|vignette|center|upright=1.5|Boitier imprimés]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clés (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

CleUSB

2016-04-23T16:28:15Z

Cleusb : /* {{Bleu|Conception d'un boitier pour la clé}} */

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser, dans un premier temps, une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra également permettre stocker et saisir des mots de passes. Pour cela nous avons réalisé successivement plusieurs clés, la première servant uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Etant donné que nous devons utiliser le port USB comme liaison série et comme clavier virtuel, nous avons basé notre projet sur un microcontrôleur ATMEGA32U4 car les deux fonction sont intégrées dans celui-ci. Nous avons donc repris le schéma de l'ARDUINO LEONARDO qui utilise un ATMEGA32U4, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation externe et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des signaux et des mesures. 
Nous avons ajouté 4 boutons et 4 LEDs sur le port D maintenant inutilisé. 
Dans cette première version, nous avons conservé par sécurité un connecteur ISP pour la programmation, mais l'objectif est de se passer de l'ISP et de programmer la carte par USB.

Voici la première version de la clé USB:

[[Image:USB1-photo.jpg|vignette|left|upright=1.5]]
[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous avons installé un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation ZIF et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé le boitier d'adaptation à notre disposition, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous avons donc créé une nouvelle carte d'adaptation sur laquelle souder le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de Remote_ au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous avons également réalisé une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprime donc le connecteur utilisé dans la précédente clé. Le connecteur ISP est également supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour certaines résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage. 
Nous avons ajouté des morceaux de clinquant sur les connecteurs USB affin de corriger une erreur de dimensionnement de celle-ci et d'augmenter l'épaisseur du connecteur. En effet, le PCB est trop fin donc dans certain ports USB trop larges, il n'y a pas de contact entre les connecteur mâle et femelle.

[[Image:USB2-photo.jpg|vignette|upright=3|left|Schéma]]
[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


={{Rouge|Gestion de mot de passe}}=

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

=={{Bleu|Protocole de communication}}==
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

=={{Bleu|Fonctionnement du microcontrôleur}}==
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensibles lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

=={{Bleu|Interface graphique}}==
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlP5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{|
|-
|[[Image:GUI-etape1.png|vignette|left|upright=1.5|1ère étape: choix de l'identifiant à modifier]]||
[[Image:GUI-etape2.png|vignette|left|upright=1.5|2ème étape: modification du mot de passe et de l'identifiant]]
|}

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mots de passes
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décalage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interruption déclenchée lors de la sélection d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interruption déclenchée lors de l'appui sur le bouton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //après 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //après 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (vias plus espacés), et d'inclure un anneau pour fixer un porte clé. Nous avons également modifié le composant du connecteur USB afin d'ajouter une surface métallique au dos du connecteur pour souder une plaque de clinquant.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB. Ce boitier a été réalisé par impression 3D. 
Voici les dimensions des deux éléments du boitier ainsi qu'un aperçu du résultat :
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|-
| [[Image:USB-boitier.jpg|vignette|center|upright=1.5|Boitier imprimés]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clé (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

Fichier:USB-boitier.jpg

2016-04-23T16:25:42Z

Cleusb :

CleUSB

2016-04-23T16:20:46Z

Cleusb : /* {{Rouge|Troisième clé USB}} */

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser, dans un premier temps, une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra également permettre stocker et saisir des mots de passes. Pour cela nous avons réalisé successivement plusieurs clés, la première servant uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Etant donné que nous devons utiliser le port USB comme liaison série et comme clavier virtuel, nous avons basé notre projet sur un microcontrôleur ATMEGA32U4 car les deux fonction sont intégrées dans celui-ci. Nous avons donc repris le schéma de l'ARDUINO LEONARDO qui utilise un ATMEGA32U4, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation externe et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des signaux et des mesures. 
Nous avons ajouté 4 boutons et 4 LEDs sur le port D maintenant inutilisé. 
Dans cette première version, nous avons conservé par sécurité un connecteur ISP pour la programmation, mais l'objectif est de se passer de l'ISP et de programmer la carte par USB.

Voici la première version de la clé USB:

[[Image:USB1-photo.jpg|vignette|left|upright=1.5]]
[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous avons installé un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation ZIF et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé le boitier d'adaptation à notre disposition, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous avons donc créé une nouvelle carte d'adaptation sur laquelle souder le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de Remote_ au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous avons également réalisé une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprime donc le connecteur utilisé dans la précédente clé. Le connecteur ISP est également supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour certaines résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage. 
Nous avons ajouté des morceaux de clinquant sur les connecteurs USB affin de corriger une erreur de dimensionnement de celle-ci et d'augmenter l'épaisseur du connecteur. En effet, le PCB est trop fin donc dans certain ports USB trop larges, il n'y a pas de contact entre les connecteur mâle et femelle.

[[Image:USB2-photo.jpg|vignette|upright=3|left|Schéma]]
[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


={{Rouge|Gestion de mot de passe}}=

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

=={{Bleu|Protocole de communication}}==
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

=={{Bleu|Fonctionnement du microcontrôleur}}==
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensibles lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

=={{Bleu|Interface graphique}}==
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlP5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{|
|-
|[[Image:GUI-etape1.png|vignette|left|upright=1.5|1ère étape: choix de l'identifiant à modifier]]||
[[Image:GUI-etape2.png|vignette|left|upright=1.5|2ème étape: modification du mot de passe et de l'identifiant]]
|}

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mots de passes
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décalage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interruption déclenchée lors de la sélection d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interruption déclenchée lors de l'appui sur le bouton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //après 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //après 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (vias plus espacés), et d'inclure un anneau pour fixer un porte clé. Nous avons également modifié le composant du connecteur USB afin d'ajouter une surface métallique au dos du connecteur pour souder une plaque de clinquant.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clé (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

CleUSB

2016-04-23T16:17:01Z

Cleusb : /* {{Bleu|Conception de la deuxième carte}} */

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser, dans un premier temps, une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra également permettre stocker et saisir des mots de passes. Pour cela nous avons réalisé successivement plusieurs clés, la première servant uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Etant donné que nous devons utiliser le port USB comme liaison série et comme clavier virtuel, nous avons basé notre projet sur un microcontrôleur ATMEGA32U4 car les deux fonction sont intégrées dans celui-ci. Nous avons donc repris le schéma de l'ARDUINO LEONARDO qui utilise un ATMEGA32U4, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation externe et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des signaux et des mesures. 
Nous avons ajouté 4 boutons et 4 LEDs sur le port D maintenant inutilisé. 
Dans cette première version, nous avons conservé par sécurité un connecteur ISP pour la programmation, mais l'objectif est de se passer de l'ISP et de programmer la carte par USB.

Voici la première version de la clé USB:

[[Image:USB1-photo.jpg|vignette|left|upright=1.5]]
[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous avons installé un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation ZIF et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé le boitier d'adaptation à notre disposition, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous avons donc créé une nouvelle carte d'adaptation sur laquelle souder le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de Remote_ au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous avons également réalisé une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprime donc le connecteur utilisé dans la précédente clé. Le connecteur ISP est également supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour certaines résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage. 
Nous avons ajouté des morceaux de clinquant sur les connecteurs USB affin de corriger une erreur de dimensionnement de celle-ci et d'augmenter l'épaisseur du connecteur. En effet, le PCB est trop fin donc dans certain ports USB trop larges, il n'y a pas de contact entre les connecteur mâle et femelle.

[[Image:USB2-photo.jpg|vignette|upright=3|left|Schéma]]
[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


={{Rouge|Gestion de mot de passe}}=

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

=={{Bleu|Protocole de communication}}==
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

=={{Bleu|Fonctionnement du microcontrôleur}}==
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensibles lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

=={{Bleu|Interface graphique}}==
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlP5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{|
|-
|[[Image:GUI-etape1.png|vignette|left|upright=1.5|1ère étape: choix de l'identifiant à modifier]]||
[[Image:GUI-etape2.png|vignette|left|upright=1.5|2ème étape: modification du mot de passe et de l'identifiant]]
|}

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mots de passes
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décalage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interruption déclenchée lors de la sélection d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interruption déclenchée lors de l'appui sur le bouton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //après 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //après 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clé (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

CleUSB

2016-04-23T16:08:36Z

Cleusb : /* {{Bleu|Interface graphique}} */

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser, dans un premier temps, une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra également permettre stocker et saisir des mots de passes. Pour cela nous avons réalisé successivement plusieurs clés, la première servant uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Etant donné que nous devons utiliser le port USB comme liaison série et comme clavier virtuel, nous avons basé notre projet sur un microcontrôleur ATMEGA32U4 car les deux fonction sont intégrées dans celui-ci. Nous avons donc repris le schéma de l'ARDUINO LEONARDO qui utilise un ATMEGA32U4, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation externe et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des signaux et des mesures. 
Nous avons ajouté 4 boutons et 4 LEDs sur le port D maintenant inutilisé. 
Dans cette première version, nous avons conservé par sécurité un connecteur ISP pour la programmation, mais l'objectif est de se passer de l'ISP et de programmer la carte par USB.

Voici la première version de la clé USB:

[[Image:USB1-photo.jpg|vignette|left|upright=1.5]]
[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous avons installé un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation ZIF et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé le boitier d'adaptation à notre disposition, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous avons donc créé une nouvelle carte d'adaptation sur laquelle souder le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de Remote_ au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous avons également réalisé une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprime donc le connecteur utilisé dans la précédente clé. Le connecteur ISP est également supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour certaines résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:USB2-photo.jpg|vignette|upright=3|left|Schéma]]
[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


={{Rouge|Gestion de mot de passe}}=

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

=={{Bleu|Protocole de communication}}==
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

=={{Bleu|Fonctionnement du microcontrôleur}}==
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensibles lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

=={{Bleu|Interface graphique}}==
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlP5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{|
|-
|[[Image:GUI-etape1.png|vignette|left|upright=1.5|1ère étape: choix de l'identifiant à modifier]]||
[[Image:GUI-etape2.png|vignette|left|upright=1.5|2ème étape: modification du mot de passe et de l'identifiant]]
|}

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mots de passes
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décalage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interruption déclenchée lors de la sélection d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interruption déclenchée lors de l'appui sur le bouton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //après 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //après 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clé (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

CleUSB

2016-04-23T15:54:34Z

Cleusb : /* {{Bleu|Interface graphique}} */

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser, dans un premier temps, une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra également permettre stocker et saisir des mots de passes. Pour cela nous avons réalisé successivement plusieurs clés, la première servant uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Etant donné que nous devons utiliser le port USB comme liaison série et comme clavier virtuel, nous avons basé notre projet sur un microcontrôleur ATMEGA32U4 car les deux fonction sont intégrées dans celui-ci. Nous avons donc repris le schéma de l'ARDUINO LEONARDO qui utilise un ATMEGA32U4, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation externe et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des signaux et des mesures. 
Nous avons ajouté 4 boutons et 4 LEDs sur le port D maintenant inutilisé. 
Dans cette première version, nous avons conservé par sécurité un connecteur ISP pour la programmation, mais l'objectif est de se passer de l'ISP et de programmer la carte par USB.

Voici la première version de la clé USB:

[[Image:USB1-photo.jpg|vignette|left|upright=1.5]]
[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous avons installé un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation ZIF et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé le boitier d'adaptation à notre disposition, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous avons donc créé une nouvelle carte d'adaptation sur laquelle souder le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de Remote_ au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous avons également réalisé une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprime donc le connecteur utilisé dans la précédente clé. Le connecteur ISP est également supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour certaines résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:USB2-photo.jpg|vignette|upright=3|left|Schéma]]
[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


={{Rouge|Gestion de mot de passe}}=

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

=={{Bleu|Protocole de communication}}==
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

=={{Bleu|Fonctionnement du microcontrôleur}}==
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensibles lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

=={{Bleu|Interface graphique}}==
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlP5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

[[Image:GUI-etape1.png|vignette|left|upright=1.5|1ère étape: choix de l'identifiant à modifier]]
[[Image:GUI-etape2.png|vignette|left|upright=1.5|2ème étape: modification du mot de passe et de l'identifiant]]

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mots de passes
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décalage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interruption déclenchée lors de la sélection d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interruption déclenchée lors de l'appui sur le bouton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //après 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //après 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clé (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

CleUSB

2016-04-23T09:53:44Z

Cleusb : /* {{Rouge|Deuxième clé USB}} */

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser, dans un premier temps, une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra également permettre stocker et saisir des mots de passes. Pour cela nous avons réalisé successivement plusieurs clés, la première servant uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Etant donné que nous devons utiliser le port USB comme liaison série et comme clavier virtuel, nous avons basé notre projet sur un microcontrôleur ATMEGA32U4 car les deux fonction sont intégrées dans celui-ci. Nous avons donc repris le schéma de l'ARDUINO LEONARDO qui utilise un ATMEGA32U4, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation externe et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des signaux et des mesures. 
Nous avons ajouté 4 boutons et 4 LEDs sur le port D maintenant inutilisé. 
Dans cette première version, nous avons conservé par sécurité un connecteur ISP pour la programmation, mais l'objectif est de se passer de l'ISP et de programmer la carte par USB.

Voici la première version de la clé USB:

[[Image:USB1-photo.jpg|vignette|left|upright=1.5]]
[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous avons installé un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation ZIF et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé le boitier d'adaptation à notre disposition, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous avons donc créé une nouvelle carte d'adaptation sur laquelle souder le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de Remote_ au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous avons également réalisé une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprime donc le connecteur utilisé dans la précédente clé. Le connecteur ISP est également supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour certaines résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:USB2-photo.jpg|vignette|upright=3|left|Schéma]]
[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


={{Rouge|Gestion de mot de passe}}=

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

=={{Bleu|Protocole de communication}}==
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

=={{Bleu|Fonctionnement du microcontrôleur}}==
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensibles lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

=={{Bleu|Interface graphique}}==
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlP5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

[[Image:GUI-etape1.png|vignette]]
[[Image:GUI-etape2.png|vignette]]

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mots de passes
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décalage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interruption déclenchée lors de la sélection d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interruption déclenchée lors de l'appui sur le bouton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //après 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //après 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clé (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

Fichier:GUI-etape2.png

2016-04-23T09:50:34Z

Cleusb :

Fichier:GUI-etape1.png

2016-04-23T09:48:54Z

Cleusb :

Fichier:USB2-photo.jpg

2016-04-23T09:37:44Z

Cleusb :

CleUSB

2016-04-23T09:33:23Z

Cleusb : /* {{Rouge|Réglage du volume}} */

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser, dans un premier temps, une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra également permettre stocker et saisir des mots de passes. Pour cela nous avons réalisé successivement plusieurs clés, la première servant uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Etant donné que nous devons utiliser le port USB comme liaison série et comme clavier virtuel, nous avons basé notre projet sur un microcontrôleur ATMEGA32U4 car les deux fonction sont intégrées dans celui-ci. Nous avons donc repris le schéma de l'ARDUINO LEONARDO qui utilise un ATMEGA32U4, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation externe et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des signaux et des mesures. 
Nous avons ajouté 4 boutons et 4 LEDs sur le port D maintenant inutilisé. 
Dans cette première version, nous avons conservé par sécurité un connecteur ISP pour la programmation, mais l'objectif est de se passer de l'ISP et de programmer la carte par USB.

Voici la première version de la clé USB:

[[Image:USB1-photo.jpg|vignette|left|upright=1.5]]
[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous avons installé un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation ZIF et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé le boitier d'adaptation à notre disposition, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous avons donc créé une nouvelle carte d'adaptation sur laquelle souder le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de Remote_ au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensible lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clé (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

CleUSB

2016-04-23T09:28:48Z

Cleusb : /* {{Rouge|Bootloader}} */

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser, dans un premier temps, une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra également permettre stocker et saisir des mots de passes. Pour cela nous avons réalisé successivement plusieurs clés, la première servant uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Etant donné que nous devons utiliser le port USB comme liaison série et comme clavier virtuel, nous avons basé notre projet sur un microcontrôleur ATMEGA32U4 car les deux fonction sont intégrées dans celui-ci. Nous avons donc repris le schéma de l'ARDUINO LEONARDO qui utilise un ATMEGA32U4, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation externe et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des signaux et des mesures. 
Nous avons ajouté 4 boutons et 4 LEDs sur le port D maintenant inutilisé. 
Dans cette première version, nous avons conservé par sécurité un connecteur ISP pour la programmation, mais l'objectif est de se passer de l'ISP et de programmer la carte par USB.

Voici la première version de la clé USB:

[[Image:USB1-photo.jpg|vignette|left|upright=1.5]]
[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous avons installé un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation ZIF et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé le boitier d'adaptation à notre disposition, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous avons donc créé une nouvelle carte d'adaptation sur laquelle souder le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensible lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clé (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

CleUSB

2016-04-23T09:23:55Z

Cleusb : /* {{Rouge|Conception de la première clé}} */

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser, dans un premier temps, une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra également permettre stocker et saisir des mots de passes. Pour cela nous avons réalisé successivement plusieurs clés, la première servant uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Etant donné que nous devons utiliser le port USB comme liaison série et comme clavier virtuel, nous avons basé notre projet sur un microcontrôleur ATMEGA32U4 car les deux fonction sont intégrées dans celui-ci. Nous avons donc repris le schéma de l'ARDUINO LEONARDO qui utilise un ATMEGA32U4, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation externe et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des signaux et des mesures. 
Nous avons ajouté 4 boutons et 4 LEDs sur le port D maintenant inutilisé. 
Dans cette première version, nous avons conservé par sécurité un connecteur ISP pour la programmation, mais l'objectif est de se passer de l'ISP et de programmer la carte par USB.

Voici la première version de la clé USB:

[[Image:USB1-photo.jpg|vignette|left|upright=1.5]]
[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous allons installer un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé ce boitier d'adaptation, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous allons donc créer une nouvelle carte d'adaptation sur laquelle nous souderons le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensible lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clé (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

CleUSB

2016-04-23T09:20:30Z

Cleusb : /* {{Rouge|Conception de la première clé}} */

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser, dans un premier temps, une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra également permettre stocker et saisir des mots de passes. Pour cela nous avons réalisé successivement plusieurs clés, la première servant uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Etant donné que nous devons utiliser le port USB comme liaison série et comme clavier virtuel, nous avons basé notre projet sur un microcontrôleur ATMEGA32U4 car les deux fonction sont intégrées dans celui-ci. Nous avons donc repris le schéma de l'ARDUINO LEONARDO qui utilise un ATMEGA32U4, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation externe et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des signaux et des mesures. 
Nous avons ajouté 4 boutons et 4 LEDs sur le port D maintenant inutilisé. 

Voici la première version de la clé USB:

[[Image:USB1-photo.jpg|vignette|left|upright=1.5]]
[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous allons installer un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé ce boitier d'adaptation, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous allons donc créer une nouvelle carte d'adaptation sur laquelle nous souderons le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensible lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clé (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

CleUSB

2016-04-23T09:17:53Z

Cleusb : /* {{Rouge|Conception de la première clé}} */

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser, dans un premier temps, une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra également permettre stocker et saisir des mots de passes. Pour cela nous avons réalisé successivement plusieurs clés, la première servant uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Etant donné que nous devons utiliser le port USB comme liaison série et comme clavier virtuel, nous avons basé notre projet sur un microcontrôleur ATMEGA32U4 car les deux fonction sont intégrées dans celui-ci. Nous avons donc repris le schéma de l'ARDUINO LEONARDO qui utilise un ATMEGA32U4, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation externe et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des signaux et des mesures. 
Nous allons ajouter sur le port D maintenant inutilisé 4 boutons et 4 LEDs.

Voici la première version de la clé USB:

[[Image:USB1-photo.jpg|vignette|left|upright=1.5]]
[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous allons installer un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé ce boitier d'adaptation, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous allons donc créer une nouvelle carte d'adaptation sur laquelle nous souderons le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensible lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clé (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

CleUSB

2016-04-23T09:12:12Z

Cleusb :

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser, dans un premier temps, une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra également permettre stocker et saisir des mots de passes. Pour cela nous avons réalisé successivement plusieurs clés, la première servant uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Etant donné que nous devons utiliser le port USB comme liaison série et comme clavier virtuel, nous avons basé notre projet sur un microcontrôleur ATMEGA32U4 car les deux fonction sont intégrées dans celui-ci. Nous avons donc repris le schéma de l'ARDUINO LEONARDO qui utilise un ATMEGA32U4, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation externe et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des signaux et des mesures. 
Nous allons ajouter sur le port D maintenant inutilisé 4 boutons et 4 LEDs.

Voici la première version de la clé USB:

USB1-photo.jpg
[[Image:Schéma USB1-photo.jpg|vignette|left|upright=1.5]]
[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous allons installer un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé ce boitier d'adaptation, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous allons donc créer une nouvelle carte d'adaptation sur laquelle nous souderons le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensible lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clé (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

Fichier:USB1-photo.jpg

2016-04-23T09:10:57Z

Cleusb :

CleUSB

2016-04-23T09:04:08Z

Cleusb :

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra pouvoir stocker et saisir des mots de passes. Pour cela nous avons réalisé successivement plusieurs clés, la première servant uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Etant donné que nous devons utiliser le port USB comme liaison série et comme clavier virtuel, nous avons basé notre projet sur un microcontrôleur ATMEGA32U4 car les deux fonction sont intégrées dans celui-ci. Nous avons donc repris le schéma de l'ARDUINO LEONARDO qui utilise un ATMEGA32U4, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation externe et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des signaux et des mesures. 
Nous allons ajouter sur le port D maintenant inutilisé 4 boutons et 4 LEDs.

Voici la première version de la clé USB:

[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous allons installer un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé ce boitier d'adaptation, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous allons donc créer une nouvelle carte d'adaptation sur laquelle nous souderons le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensible lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clé (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

CleUSB

2016-03-28T13:35:22Z

Cleusb :

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra pouvoir stocker et saisir des mots de passes. Pour cela nous allons réaliser successivement plusieurs clés, la première servira uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Notre projet est basé sur un ATMEGA32U4, nous avons donc repris le schéma de l'ARDUINO LEONARDO, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des mesures. 
Nous allons ajouter sur le port D maintenant inutilisé 4 boutons et 4 LEDs

Voici la première version de la clé USB:

[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous allons installer un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé ce boitier d'adaptation, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous allons donc créer une nouvelle carte d'adaptation sur laquelle nous souderons le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensible lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Voici les fichiers utiles pour la réalisation des clé (typons, routage, programmes):
*[[Media:Fichiers_utiles.zip]]

Fichier:Fichiers utiles.zip

2016-03-28T13:31:20Z

Cleusb :

CleUSB

2016-03-28T13:18:43Z

Cleusb : /* {{Vert|Fonctionnement du microcontrôleur}} */

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra pouvoir stocker et saisir des mots de passes. Pour cela nous allons réaliser successivement plusieurs clés, la première servira uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Notre projet est basé sur un ATMEGA32U4, nous avons donc repris le schéma de l'ARDUINO LEONARDO, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des mesures. 
Nous allons ajouter sur le port D maintenant inutilisé 4 boutons et 4 LEDs

Voici la première version de la clé USB:

[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous allons installer un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé ce boitier d'adaptation, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous allons donc créer une nouvelle carte d'adaptation sur laquelle nous souderons le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensible lors de la première utilisation.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

CleUSB

2016-03-28T13:15:45Z

Cleusb : /* {{Bleu|Gestion de mot de passe}} */

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra pouvoir stocker et saisir des mots de passes. Pour cela nous allons réaliser successivement plusieurs clés, la première servira uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Notre projet est basé sur un ATMEGA32U4, nous avons donc repris le schéma de l'ARDUINO LEONARDO, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des mesures. 
Nous allons ajouter sur le port D maintenant inutilisé 4 boutons et 4 LEDs

Voici la première version de la clé USB:

[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous allons installer un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé ce boitier d'adaptation, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous allons donc créer une nouvelle carte d'adaptation sur laquelle nous souderons le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 16 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>
void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/

</source>


La fonction initialisation() est appelée dans le setup() la première fois que le programme est utilisé.
Cette fonction initialise chaque emplacement pour mots de passe et identifiants avec le mot "nouveau".
pour savoir si le programme est exécuté pour la première fois, nous utilisons la valeur stockée dans le premier emplacement de l'EEPROM, si cet emplacement vaut 1, l'initialisation a déjà été effectuée lors d'une utilisation précédente.
Cette initialisation permet à l'utilisateur de l'interface graphique de voir apparaître "nouveau" plutôt qu'une chaîne de caractères incompréhensible.


<source lang=cpp>
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
/*lecture des informations transmises par l'interface graphique sur le port série*/
if (Serial.available()) {
int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;
}
if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();
}

/*lecture boutons*/
static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];
}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

CleUSB

2016-03-28T12:52:11Z

Cleusb :

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra pouvoir stocker et saisir des mots de passes. Pour cela nous allons réaliser successivement plusieurs clés, la première servira uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Notre projet est basé sur un ATMEGA32U4, nous avons donc repris le schéma de l'ARDUINO LEONARDO, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des mesures. 
Nous allons ajouter sur le port D maintenant inutilisé 4 boutons et 4 LEDs

Voici la première version de la clé USB:

[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous allons installer un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé ce boitier d'adaptation, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous allons donc créer une nouvelle carte d'adaptation sur laquelle nous souderons le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande. 
(Il n'est pas possible d'utiliser d'utiliser une version pré-modifiée de ces fichiers, car les programmes HID.cpp et USBAPI.h peuvent varier en fonction du système d'exploitation utilisé ou de la version d'ARDUINO. Pour éviter les problèmes de compatibilité, il est préférable d'apporter les modifications suivantes aux fichiers fournis avec le logiciel)

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 10 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>

void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
if (Serial.available()) {

int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;

}

if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();

}

static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];

}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

CleUSB

2016-03-28T12:38:26Z

Cleusb :

[[Catégorie:projets]]

[[Image:Clé_USB_HARENDARZ.jpg|vignette|center]]

L'objectif de ce projet est de réaliser une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra pouvoir servir de télécommande ou stocker et saisir des mots de passes. Pour cela nous allons réaliser successivement plusieurs clés, la première servira uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Notre projet est basé sur un ATMEGA32U4, nous avons donc repris le schéma de l'ARDUINO LEONARDO, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des mesures. 
Nous allons ajouter sur le port D maintenant inutilisé 4 boutons et 4 LEDs

Voici la première version de la clé USB:

[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous allons installer un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé ce boitier d'adaptation, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous allons donc créer une nouvelle carte d'adaptation sur laquelle nous souderons le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande.

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

Voici le fichier USBAPI.h modifié(les fichiers .cpp ne peuvent pas etre importé sur le wiki):
*[[Media:USBAPI.h]]

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 10 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>

void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
if (Serial.available()) {

int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;

}

if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();

}

static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];

}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Fichier:Clé USB HARENDARZ.jpg

2016-03-28T12:35:41Z

Cleusb : Cleusb a téléversé une nouvelle version de Fichier:Clé USB HARENDARZ.jpg

Fichier:Clé USB HARENDARZ.jpg

2016-03-28T12:32:51Z

Cleusb :

CleUSB

2016-03-26T02:41:21Z

Cleusb : /* {{Rouge|Troisième clé USB}} */

[[Catégorie:projets]]

L'objectif de ce projet est de réaliser une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra pouvoir servir de télécommande ou stocker et saisir des mots de passes. Pour cela nous allons réaliser successivement plusieurs clés, la première servira uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Notre projet est basé sur un ATMEGA32U4, nous avons donc repris le schéma de l'ARDUINO LEONARDO, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des mesures. 
Nous allons ajouter sur le port D maintenant inutilisé 4 boutons et 4 LEDs

Voici la première version de la clé USB:

[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous allons installer un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé ce boitier d'adaptation, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous allons donc créer une nouvelle carte d'adaptation sur laquelle nous souderons le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande.

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

Voici le fichier USBAPI.h modifié(les fichiers .cpp ne peuvent pas etre importé sur le wiki):
*[[Media:USBAPI.h]]

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 10 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>

void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
if (Serial.available()) {

int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;

}

if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();

}

static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];

}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=1.5|Board]] || [[Image:USB3_percage.png|vignette|upright=1.5|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=1.5|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=1.5|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=1.5|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=1.5|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=1.5|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=1.5|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

CleUSB

2016-03-26T02:39:21Z

Cleusb : /* {{Bleu|Problèmes rencontrés}} */

[[Catégorie:projets]]

L'objectif de ce projet est de réaliser une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra pouvoir servir de télécommande ou stocker et saisir des mots de passes. Pour cela nous allons réaliser successivement plusieurs clés, la première servira uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Notre projet est basé sur un ATMEGA32U4, nous avons donc repris le schéma de l'ARDUINO LEONARDO, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des mesures. 
Nous allons ajouter sur le port D maintenant inutilisé 4 boutons et 4 LEDs

Voici la première version de la clé USB:

[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous allons installer un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé ce boitier d'adaptation, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous allons donc créer une nouvelle carte d'adaptation sur laquelle nous souderons le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=1.5]] || [[Image:Board adaptation USB.png|vignette|upright=1.5]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande.

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

Voici le fichier USBAPI.h modifié(les fichiers .cpp ne peuvent pas etre importé sur le wiki):
*[[Media:USBAPI.h]]

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 10 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>

void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
if (Serial.available()) {

int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;

}

if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();

}

static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];

}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=2|Board]] || [[Image:USB3_percage.png|vignette|upright=2|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=2|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=2|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=2|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=2|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=2|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=2|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=2|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=2|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

CleUSB

2016-03-26T02:38:35Z

Cleusb : /* {{Rouge|Conception de la première clé}} */

[[Catégorie:projets]]

L'objectif de ce projet est de réaliser une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra pouvoir servir de télécommande ou stocker et saisir des mots de passes. Pour cela nous allons réaliser successivement plusieurs clés, la première servira uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Notre projet est basé sur un ATMEGA32U4, nous avons donc repris le schéma de l'ARDUINO LEONARDO, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des mesures. 
Nous allons ajouter sur le port D maintenant inutilisé 4 boutons et 4 LEDs

Voici la première version de la clé USB:

[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=1.5|Routage]] || [[Image:Percage_USB1.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=1.5|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=1.5|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous allons installer un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé ce boitier d'adaptation, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous allons donc créer une nouvelle carte d'adaptation sur laquelle nous souderons le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=2]] || [[Image:Board adaptation USB.png|vignette|upright=2]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande.

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

Voici le fichier USBAPI.h modifié(les fichiers .cpp ne peuvent pas etre importé sur le wiki):
*[[Media:USBAPI.h]]

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 10 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>

void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
if (Serial.available()) {

int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;

}

if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();

}

static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];

}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=2|Board]] || [[Image:USB3_percage.png|vignette|upright=2|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=2|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=2|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=2|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=2|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=2|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=2|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=2|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=2|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

CleUSB

2016-03-26T02:37:56Z

Cleusb : /* {{Bleu|Conception de la deuxième carte}} */

[[Catégorie:projets]]

L'objectif de ce projet est de réaliser une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra pouvoir servir de télécommande ou stocker et saisir des mots de passes. Pour cela nous allons réaliser successivement plusieurs clés, la première servira uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Notre projet est basé sur un ATMEGA32U4, nous avons donc repris le schéma de l'ARDUINO LEONARDO, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des mesures. 
Nous allons ajouter sur le port D maintenant inutilisé 4 boutons et 4 LEDs

Voici la première version de la clé USB:

[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=2|Routage]] || [[Image:Percage_USB1.png|vignette|upright=2|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=2|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=2|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous allons installer un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé ce boitier d'adaptation, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous allons donc créer une nouvelle carte d'adaptation sur laquelle nous souderons le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=2]] || [[Image:Board adaptation USB.png|vignette|upright=2]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande.

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

Voici le fichier USBAPI.h modifié(les fichiers .cpp ne peuvent pas etre importé sur le wiki):
*[[Media:USBAPI.h]]

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=1.5|Board]] || [[Image:Perçage_USB2.png|vignette|upright=1.5|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=1.5|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=1.5|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 10 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>

void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
if (Serial.available()) {

int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;

}

if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();

}

static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];

}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=2|Board]] || [[Image:USB3_percage.png|vignette|upright=2|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=2|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=2|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=2|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=2|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=2|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=2|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=2|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=2|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

CleUSB

2016-03-26T02:35:50Z

Cleusb : /* {{Bleu|Conception d'un boitier pour la clé}} */

[[Catégorie:projets]]

L'objectif de ce projet est de réaliser une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra pouvoir servir de télécommande ou stocker et saisir des mots de passes. Pour cela nous allons réaliser successivement plusieurs clés, la première servira uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Notre projet est basé sur un ATMEGA32U4, nous avons donc repris le schéma de l'ARDUINO LEONARDO, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des mesures. 
Nous allons ajouter sur le port D maintenant inutilisé 4 boutons et 4 LEDs

Voici la première version de la clé USB:

[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=2|Routage]] || [[Image:Percage_USB1.png|vignette|upright=2|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=2|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=2|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous allons installer un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé ce boitier d'adaptation, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous allons donc créer une nouvelle carte d'adaptation sur laquelle nous souderons le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=2]] || [[Image:Board adaptation USB.png|vignette|upright=2]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande.

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

Voici le fichier USBAPI.h modifié(les fichiers .cpp ne peuvent pas etre importé sur le wiki):
*[[Media:USBAPI.h]]

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=2|Board]] || [[Image:Perçage_USB2.png|vignette|upright=2|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=2|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=2|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 10 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>

void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
if (Serial.available()) {

int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;

}

if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();

}

static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];

}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=2|Board]] || [[Image:USB3_percage.png|vignette|upright=2|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=2|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=2|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|center|upright=2|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|center|upright=2|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|center|upright=2|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|center|upright=2|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|center|upright=2|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|center|upright=2|aperçu]]
|}

=={{Bleu|Correction}}==
Nous n'avions pas pris en compte le boitier lors de la réalisation de la clé. Avec l’épaisseur de celui ci, il n'est plus possible de relier le connecteur USB à un connecteur USB femelle. Pour utiliser le boitier il est donc nécessaire d'allonger le connecteur USB.
[[Image:USB3_board_final.png|vignette|center|upright=2|aperçu]]

Fichier:USB3 board final.png

2016-03-26T02:34:31Z

Cleusb :

CleUSB

2016-03-26T02:05:50Z

Cleusb : /* {{Rouge|Troisième clé USB}} */

[[Catégorie:projets]]

L'objectif de ce projet est de réaliser une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra pouvoir servir de télécommande ou stocker et saisir des mots de passes. Pour cela nous allons réaliser successivement plusieurs clés, la première servira uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Notre projet est basé sur un ATMEGA32U4, nous avons donc repris le schéma de l'ARDUINO LEONARDO, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des mesures. 
Nous allons ajouter sur le port D maintenant inutilisé 4 boutons et 4 LEDs

Voici la première version de la clé USB:

[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=2|Routage]] || [[Image:Percage_USB1.png|vignette|upright=2|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=2|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=2|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous allons installer un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé ce boitier d'adaptation, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous allons donc créer une nouvelle carte d'adaptation sur laquelle nous souderons le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=2]] || [[Image:Board adaptation USB.png|vignette|upright=2]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande.

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

Voici le fichier USBAPI.h modifié(les fichiers .cpp ne peuvent pas etre importé sur le wiki):
*[[Media:USBAPI.h]]

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=2|Board]] || [[Image:Perçage_USB2.png|vignette|upright=2|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=2|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=2|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 10 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>

void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
if (Serial.available()) {

int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;

}

if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();

}

static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];

}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=2|Board]] || [[Image:USB3_percage.png|vignette|upright=2|Perçage et détourrage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=2|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=2|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.
{|
! Boitier inférieur !! Boitier supérieur
|-
| [[Image:Inférieur_vue_dessus.png|vignette|upright=2|vue dessus]] || [[Image:Supérieur_vue_dessus.png|vignette|upright=2|vue dessus]]
|-
| [[Image:Inférieur_vue_face.png|vignette|upright=2|vue coté connecteur USB]] || [[Image:Supérieur_vue_face.png|vignette|upright=2|vue coté connecteur USB]]
|-
| [[Image:Aperçu_boitier_inférieur.png|vignette|upright=2|aperçu]] || [[Image:Aperçu_boitier_supérieur.png|vignette|upright=2|aperçu]]
|}

Fichier:Aperçu boitier inférieur.png

2016-03-26T02:01:20Z

Cleusb : Cleusb a téléversé une nouvelle version de Fichier:Aperçu boitier inférieur.png

Fichier:Aperçu boitier supérieur.png

2016-03-26T01:59:21Z

Cleusb :

Fichier:Aperçu boitier inférieur.png

2016-03-26T01:46:54Z

Cleusb :

Fichier:Supérieur vue face.png

2016-03-26T01:44:26Z

Cleusb :

Fichier:Inférieur vue face.png

2016-03-26T01:43:38Z

Cleusb :

Fichier:Supérieur vue dessus.png

2016-03-26T01:42:51Z

Cleusb :

Fichier:Inférieur vue dessus.png

2016-03-26T01:42:01Z

Cleusb :

CleUSB

2016-03-25T20:18:26Z

Cleusb : /* {{Rouge|Troisième clé USB}} */

[[Catégorie:projets]]

L'objectif de ce projet est de réaliser une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra pouvoir servir de télécommande ou stocker et saisir des mots de passes. Pour cela nous allons réaliser successivement plusieurs clés, la première servira uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Notre projet est basé sur un ATMEGA32U4, nous avons donc repris le schéma de l'ARDUINO LEONARDO, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des mesures. 
Nous allons ajouter sur le port D maintenant inutilisé 4 boutons et 4 LEDs

Voici la première version de la clé USB:

[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=2|Routage]] || [[Image:Percage_USB1.png|vignette|upright=2|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=2|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=2|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous allons installer un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé ce boitier d'adaptation, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous allons donc créer une nouvelle carte d'adaptation sur laquelle nous souderons le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=2]] || [[Image:Board adaptation USB.png|vignette|upright=2]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande.

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

Voici le fichier USBAPI.h modifié(les fichiers .cpp ne peuvent pas etre importé sur le wiki):
*[[Media:USBAPI.h]]

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=2|Board]] || [[Image:Perçage_USB2.png|vignette|upright=2|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=2|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=2|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 10 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>

void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
if (Serial.available()) {

int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;

}

if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();

}

static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];

}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=

=={{Bleu|Conception de la troisième carte}}==

La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

{|
|-
| [[Image:USB3_board.png|vignette|upright=2|Board]] || [[Image:USB3_percage.png|vignette|upright=2|Perçage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=2|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=2|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Nous avons conçu un boitier pour cette dernière version de la clé USB.

CleUSB

2016-03-25T17:44:47Z

Cleusb :

[[Catégorie:projets]]

L'objectif de ce projet est de réaliser une clé USB capable de régler le volume de l'ordinateur sur lequel elle est branchée. Dans un deuxième temps, la clé devra pouvoir servir de télécommande ou stocker et saisir des mots de passes. Pour cela nous allons réaliser successivement plusieurs clés, la première servira uniquement à envoyer des informations à l'ordinateur afin d'ajuster le volume.

={{Rouge|Conception de la première clé}}=

Notre projet est basé sur un ATMEGA32U4, nous avons donc repris le schéma de l'ARDUINO LEONARDO, en ne conservant que la partie utile à notre clé USB. Ainsi nous pouvons supprimer les entrées et sorties ARDUINO. La carte sera toujours alimentée par USB donc la borne de connexion pour alimentation et le système de régulation de tension peuvent être supprimés. L'objectif étant de miniaturiser au maximum la carte, nous avons décidé de supprimer également les inductances et condensateurs destinés à l'amélioration de la qualité des mesures. 
Nous allons ajouter sur le port D maintenant inutilisé 4 boutons et 4 LEDs

Voici la première version de la clé USB:

[[Image:Schéma USB1.png|vignette|left|upright=4]]
{|
|-
| [[Image:Board_USB1.png|vignette|upright=2|Routage]] || [[Image:Percage_USB1.png|vignette|upright=2|Perçage]]
|-
| [[Image:Composants top USB1.png|vignette|upright=2|placement composants top]] || [[Image:Composants bottom USB1.png|vignette|upright=2|Placement composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R1206
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 1M || R1206
|-
| 2 || 22R || R1206
|-
| 1 || (ISP) || MA03-2
|-
| 1 || 100nF || C1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:HARENDARZ_DISSISSA_USB1.sch]]
*[[Media:HARENDARZ_DISSISSA_USB1.brd]]

={{Rouge|Bootloader}}=

Afin de téléverser les programmes sans utiliser le connecteur ISP et d’exécuter le programme à la mise sous tension du microcontrôleur, nous allons installer un bootloader sur l'ATMEGA32U4.
Pour cela, avant de le souder sur la carte, nous plaçons le microcontrôleur dans un boitier d'adaptation et utilisons l'outil "graver la séquence d'initialisation" du logiciel ARDUINO.
Dans la première version de la carte nous avons conservé l'ISP comme sécurité si le bootloader ne fonctionne pas.

=={{Bleu|Problèmes rencontrés}}==
Le connecteur ISP de la carte sur laquelle est soudé ce boitier d'adaptation, ne sont pas reliées aux bonnes broches du microcontrôleur. Nous allons donc créer une nouvelle carte d'adaptation sur laquelle nous souderons le boitier. Les broches à connecter sont:

{| class="wikitable"
|-
! Nom !! Broche ATMEGA32U4
|-
| MISO || 11
|-
| MOSI || 10
|-
| SCLK || 9
|-
| /RESET || 13
|-
| VCC || 14,34
|-
| GND || 15,23,35,43
|-
| Quartz || 16,17
|}

Le boitier n'étant pas au format standard, il faut recréer le composant sur Eagle.
*[[Media:Adaptation_ATMEGA32U4.lbr]]

voici la carte d'adaptation que nous avons réalisé.
{|
|-
| [[Image:Schéma adaptation USB.png|vignette|upright=2]] || [[Image:Board adaptation USB.png|vignette|upright=2]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
|1||(ISP)||MA03-2
|-
|1||1MR||R1206
|-
|1||(quartz 16MHz)||
|-
|1||(adaptateur ATMEGA32U4)||
|}
*[[Media:Carte_adaptation.sch]]
*[[Media:Carte_adaptation.brd]]

={{Rouge|Réglage du volume}}=
=={{Bleu|Modification des programmes ARDUINO}}==
Pour ajuster le volume d'un ordinateur, il existe 3 caractères spéciaux nommés XF86volume_up, XF86volume_down et XF86volume_mute.
Pour pouvoir envoyer ces caractères, il faut modifier les fichiers ARDUINO HID.cpp et USBAPI.h qui gèrent la partie "périphérique USB" de l'ARDUINO LEONARDO.
Voici un exemple de modification que nous avons trouvé qui ajoute à l'interface homme-machine la classe Remote permettant l'usage de fonctions de base d'une télécommande.

{{boîte déroulante/début|titre=USBAPI.h}}
| On déclare la classe Remote_ après les classes Keyboard_ et Mouse_ : 

<source lang=cpp>
//================================================================================
//================================================================================
// Remote

#define REMOTE_CLEAR 0
#define VOLUME_UP 1
#define VOLUME_DOWN 2
#define VOLUME_MUTE 4
#define REMOTE_PLAY 8
#define REMOTE_PAUSE 16
#define REMOTE_STOP 32
#define REMOTE_NEXT 64
#define REMOTE_PREVIOUS 128
#define REMOTE_FAST_FORWARD 256
#define REMOTE_REWIND 512

class Remote_
{
private:
public:
Remote_(void);
void begin(void);
void end(void);

// Volume
void increase(void);
void decrease(void);
void mute(void);

// Playback
void play(void);
void pause(void);
void stop(void);

// Track Controls
void next(void);
void previous(void);
void forward(void);
void rewind(void);

// Send an empty report to prevent repeated actions
void clear(void);
};
extern Remote_ Remote;
</source>{{boîte déroulante/fin}}

{{boîte déroulante/début|titre=HID.cpp}}
{| class="wikitable"
|-
| On déclare Remote l'instance de _Remote au début du programme:

<source lang=cpp>
Mouse_ Mouse;
Keyboard_ Keyboard;
Remote_ Remote;
</source>

|-
| On place l'impémentation de Remote à la fin du fichier,
après l'implémentation de Mouse et Keyboard, et avant les #endif finaux:

<source lang=c>
//================================================================================
//================================================================================
// Remote

Remote_::Remote_(void)
{
}

void Remote_::begin(void)
{
}

void Remote_::end(void)
{
}

void Remote_::increase(void)
{
u8 m[2];
m[0] = VOLUME_UP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::decrease(void)
{
u8 m[2];
m[0] = VOLUME_DOWN;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::mute(void)
{
u8 m[2];
m[0] = VOLUME_MUTE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::play(void)
{
u8 m[2];
m[0] = REMOTE_PLAY;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::pause(void)
{
u8 m[2];
m[0] = REMOTE_PAUSE;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::stop(void)
{
u8 m[2];
m[0] = REMOTE_STOP;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::next(void)
{
u8 m[2];
m[0] = REMOTE_NEXT;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::previous(void)
{
u8 m[2];
m[0] = REMOTE_PREVIOUS;
m[1] = 0;
HID_SendReport(4,m,2);
}

void Remote_::forward(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_FAST_FORWARD >> 8;
HID_SendReport(4,m,2);
}

void Remote_::rewind(void)
{
u8 m[2];
m[0] = 0;
m[1] = REMOTE_REWIND >> 8;
HID_SendReport(4,m,2);
}

void Remote_::clear(void)
{
u8 m[2];
m[0] = 0;
m[1] = 0;
HID_SendReport(4,m,2);
}
</source>

|-
|On place la description HID des élément de Remote après <source lang=c>
#if RAWHID_ENABLED
// RAW HID
...
#endif
</source> (ligne 130 environ)
<source lang=c>
//-----------------------------------------------------------------------------

/* Cross-platform support for controls found on IR Remotes */

0x05, 0x0c, // Usage Page (Consumer Devices)
0x09, 0x01, // Usage (Consumer Control)
0xa1, 0x01, // Collection (Application)
0x85, 0x04, // REPORT_ID (4)
0x15, 0x00, // Logical Minimum (0)
0x25, 0x01, // Logical Maximum (1)
0x09, 0xe9, // Usage (Volume Up)
0x09, 0xea, // Usage (Volume Down)
0x75, 0x01, // Report Size (1)
0x95, 0x02, // Report Count (2)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xe2, // Usage (Mute)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb0, // Usage (Play)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb1, // Usage (Pause)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb7, // Usage (Stop)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb5, // Usage (Next)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb6, // Usage (Previous)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb3, // Usage (Fast Forward)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x09, 0xb4, // Usage (Rewind)
0x95, 0x01, // Report Count (1)
0x81, 0x06, // Input (Data, Variable, Relative)

0x95, 0x06, // Report Count (6) Number of bits remaining in byte
0x81, 0x07, // Input (Constant, Variable, Relative)
0xc0 // End Collection
</source>
|}{{boîte déroulante/fin}}

Voici le fichier USBAPI.h modifié(les fichiers .cpp ne peuvent pas etre importé sur le wiki):
*[[Media:USBAPI.h]]

=={{Bleu|Programme de réglage du volume}}==

<source lang=cpp>
void setup(){
DDRD=0x0f;
PORTD=0xff;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PD3);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PD3);
}
if((PIND&(1<<PD5))==0){
PORTD^=1;
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=1;
}
if((PIND&(1<<PD4))==0){
PORTD^=0b0110;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b0110;
}
}
</source>


={{Rouge|Deuxième clé USB}}=

Nous devons créer un nouvelle version de la clé USB plus compacte, qui permettrait l'usage de deux programme : le programme de gestion du volume ou un programme permettant le stockage et la saisie d'identifiant et de mots de passes. Pour ce dernier, nous allons également réaliser une interface graphique pour permettre à l'utilisateur de saisir les mots de passes à mémoriser.

=={{Bleu|Conception de la deuxième carte}}==

Dans cette version de notre clé, le PCB fera office de connecteur USB mâle, on supprimera donc le connecteur utilisé dans la précédente clé. Le connecteur ISP sera aussi supprimé.
Dans le but de miniaturiser la carte, nous avons choisi d'utiliser un format de boitier plus petit pour les résistances, et la résistance associée au quartz a été supprimée. Le quartz ne peut cependant pas être supprimé, il est nécessaire pour les fonctions d'interface homme-machine que nous voulons utiliser. Les ports des entrées et sorties sont modifiés afin d'optimiser le routage.

[[Image:Schema_USB2.png|vignette|upright=3|left|Schéma]]
{|
|-
| [[Image:Board USB2.png|vignette|upright=2|Board]] || [[Image:Perçage_USB2.png|vignette|upright=2|Perçage]]
|-
| [[Image:Composants_top_USB2.png|vignette|upright=2|Composants top]] || [[Image:Composants_bottom_USB2.png|vignette|upright=2|Composants bottom]]
|}

{| class="wikitable"
|+ Nomenclature
|-
! quantité !! valeur !! package
|-
| 4 || (led) || PLCC2
|-
| 4 || 330R || R0805
|-
| 4 || (bouton poussoir) || SWITCH-6*6.5
|-
| 2 || 100nF || C1206
|-
| 2 || 22R || R1206
|-
| 1 || 1MR || R1206
|-
| 1 || 10kR || R1206
|-
| 1 || 1uF || C1206
|-
| 1 || (ATMEGA32U4) || TQFP44-PAD
|-
| 1 || quartz 16MHz ||
|-
| 1 || (USB mâle A) ||
|}

*[[Media:USB2.sch]]
*[[Media:USB2.brd]]
composant utilisé pour le connecteur USB:
*[[Media:USB male.lbr]]

=={{Bleu|Contrôle du volume}}==

Ce programme est le même que dans la partie précédente, il est juste nécessaire de changer les broches des entrées et sorties.

<source lang=c>
void setup(){
DDRD=0x00;
DDRF=0xf0;
PORTD=0xf0;
PORTF=0xf0;
}

void loop(){
if((PIND&(1<<PD6))==0){
PORTD^=(1<<PF7);
Remote.increase();
Remote.clear();
delay(1000);
PORTD^=(1<<PF7);
}
if((PIND&(1<<PD4))==0){
PORTD^=(1<<PF4);
Remote.decrease();
Remote.clear();
delay(1000);
PORTD^=(1<<PF4);
}
if((PIND&(1<<PD7))==0){
PORTD^=0b01100000;
Remote.mute();
Remote.clear();
delay(1000);
PORTD^=0b01100000;
}
}
</source>


=={{Bleu|Gestion de mot de passe}}==

Pour faciliter l'utilisation de la clé, nous avons choisi de ne stocker que 4 couples identifiants/mots de passe, ainsi, chaque bouton de la clé permet de l'envoie d'un mot de passe.
Pour la communication entre l'interface graphique et la clé, nous avons mis en place un protocole de communication.
Pour le moment, les chaines de caractères stockés doivent contenir 10 caractères ou moins, cette valeur pourra être augmenté en changeant l'adressage utilisé pour le stockage dans l'EEPROM.

==={{Vert|Protocole de communication}}===
chaque élément est séparé par le caractère '\n' (retour à la ligne).
{| class="wikitable"
|-
!scope="row"| demande de la liste des identifiants/mots de passe
| 1
|-
!scope="row"| commande de changement d'un couple
| 2 || n° du couple || identifiant || mot de passe
|-
!scope="row"| envoie de la liste des couples
| 3 || n° du 1er couple || identifiant n°1 || mot de passe n°1 || n° du 2ème couple || identifiant n°2 || ...
|}

==={{Vert|Fonctionnement du microcontrôleur}}===
{{boîte déroulante/début|titre=Programme arduino}}
 <source lang=cpp>
#include <EEPROM.h>

char bp[4] = {
1 << PD5, 1 << PD4, 1 << PD7, 1 << PD6
};
char led[4] = {
1 << PF4, 1 << PF5, 1 << PF6, 1 << PF7
};

char inBuffer[255]; //Packet à envoyer
char s[4][15]; //s[0]=num consigne; s[1]=num ID; s[2]=ID; s[3]=MP

/************************
* partie communication *
************************/

</source>

La fonction change() modifie un couple identifiant mot de passe lorsqu'on reçoit une consigne de changement venant de l'interface graphique. 
Pour réduire l'usure de l'EEPROM, on change le caractère stocké seulement si il est différent du précédent.

<source lang=cpp>
void change() {
char i = 0;
char adresse = 0x10 + s[1][0] * 0x20;
do {
if (EEPROM.read(i + adresse) != s[2][i]) EEPROM.write( i + adresse, s[2][i]);
i++;
}
while (s[2][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

i = 0;
adresse += 0x10;
do {
if (EEPROM.read(i + adresse) != s[3][i]) EEPROM.write( i + adresse, s[3][i]);
i++;
}
while (s[3][i] != 0);
if (EEPROM.read(i + adresse) != 0) EEPROM.write( i + adresse, 0);

}
</source>


La fonction liste retourne à l'interface graphique la liste des couples identifiant/mot de passe stockés


<source lang=cpp>
void liste() {
String env = ""; //chaine de stockage des caracteres à envoyer
env += '3';
env += '\n';

char adresse = 0x10;
for (int n = 0; n < 4; n++) {
env += n;
env += '\n';
char i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
i = 0;
do {
char c = EEPROM.read(adresse + i);
env += c;
i++;
}
while ((EEPROM.read(adresse + i) != 0) && (i < 0x10));
adresse += 0x10;
env += '\n';
}
Serial.println(env);
}

/**************
* partie HID *
**************/
</source> 
Partie du programme gérant les couples identifiants/mots de passe.
Le texte envoyé par l'ARDUINO LEONARDO est basé sur un clavier "qwerty" et le signal envoyé correspond à la position de la touche sur le clavier. 
La fonction translate permet de remplacer le caractère demandé par l'emplacement de ce caractère sur un clavier "qwerty". 
Il est également possible de modifier la classe Keyboard d'ARDUINO afin qu'elle utilise un clavier "azerty"


<source lang=cpp>
char translate(char c) {
switch (c) {
case '1':
c = '!';
break;
case '2':
c = '@';
break;
case '3':
c = '#';
break;
case '4':
c = '$';
break;
case '5':
c = '%';
break;
case '6':
c = '^';
break;
case '7':
c = '&';
break;
case '8':
c = '*';
break;
case '9':
c = '(';
break;
case '0':
c = ')';
break;
case '°':
c = '_';
break;
case '&':
c = '1';
break;
case 'é':
c = '2';
break;
case '"':
c = '3';
break;
case '(':
c = '5';
break;
case '-':
c = '6';
break;
case 'è':
c = '7';
break;
case '_':
c = '8';
break;
case 'ç':
c = '9';
break;
case 'à':
c = '0';
break;
case ')':
c = '-';
break;
case 'a':
c = 'q';
break;
case 'A':
c = 'Q';
break;
case 'z':
c = 'w';
break;
case 'Z':
c = 'W';
break;
case '^':
c = '[';
break;
case '$':
c = ']';
break;
case '£':
c = '}';
break;
case 'q':
c = 'a';
break;
case 'Q':
c = 'A';
break;
case 'm':
c = ';';
break;
case 'M':
c = ':';
break;
case 'µ':
c = '|';
break;
case 'w':
c = 'z';
break;
case 'W':
c = 'Z';
break;
case ',':
c = 'm';
break;
case '?':
c = 'M';
break;
case ';':
c = ',';
break;
case '.':
c = '<';
break;
case ':':
c = '.';
break;
case '/':
c = '>';
break;
case '!':
c = '/';
break;
default:
break;
}
return c;
}
</source>


La fonction login saisie le couple identifiant/mot de passe correspondant au nombre sélectionné en paramètre.


<source lang=cpp>

void login(char num) {
Keyboard.begin();
char adresse = 0x10 + 0x20 * num;
char i = 0;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.write(KEY_TAB);
i = 0;
delay(100);
adresse += 0x10;
do {
char c = EEPROM.read(adresse + i);
Keyboard.print(translate(c));
i++;
}
while (EEPROM.read(adresse + i) != 0);
Keyboard.println("");//==write(KEY_RETURN)
Keyboard.end();
}

/*********************
* partie principale *
*********************/
void initialisation() {
char val[] = {
'n', 'o', 'u', 'v', 'e', 'a', 'u'
};
char adresse = 0x10;
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 7; j++) {
EEPROM.write(adresse + i * 0x10 + j, val[j]);
}
EEPROM.write(adresse + i * 0x10 + 7, 0);
}
EEPROM.write(0, 1);
}

void setup() {
Serial.begin(9600);
if (EEPROM.read(0) != 1) initialisation();

DDRD = 0;
PORTD = 0xf0;
DDRF = 0xf0;
PORTF = 0xf0;
}

void loop() {
if (Serial.available()) {

int i = 0;
do {
char inChar = (char)Serial.read();
inBuffer[i] = inChar;
i++;
}
while (Serial.available());
inBuffer[i] = 0;

int j = 0;
int a = 0;
for (int k = 0; k < 4; k++) {
do {
s[k][j - a] = inBuffer[j];
j++;
}
while ((inBuffer[j] != '\n') && (j < 16 + a));
s[k][j - a] = 0;
j++;
a = j;

}

if (s[0][0] == '1') liste();
else if (s[0][0] == '2') change();

}

static char ePresent[4], ePasse[4];

for (char i = 0; i < 4; i++) {
ePasse[i] = ePresent[i];
ePresent[i] = PIND & bp[i];
if ((ePresent[i] == 0) && (ePasse[i] != 0)) {
PORTF ^= led[i];
login(i);
PORTF ^= led[i];

}
}
}
</source>
{{boîte déroulante/fin}}

==={{Vert|Interface graphique}}===
Nous avons choisi de réaliser notre interface graphique avec Processing. 
Nous avons crée une interface qui contient une liste d'identifiants, un bouton de modification qui fait apparaître des fenêtres de saisie pour les modifications. 
Pour utiliser notre programme, il est nécessaire d'installer la librairie controlP5 disponible dans la liste des librairie processing. 
La librairie controlp5 fournit des outils graphiques (boutons, fenêtre de saisie, menu déroulant...) facilitant l'édition d'une interface graphique. 
Lorsqu'un bouton ou un menu déroulant est créé, une fonction d’interruption portant le même nom que l'objet est disponible, cette fonction est activée par un clic sur le bouton ou un élément du menu.

{{boîte déroulante/début|titre=Programme processing}}
Normalement, le premier port série disponible devrait être la clé donc on peut initialiser la communication série sur le port Serial.list()[0]. 
Nous pourront par la suite ajouter un élément d'interface graphique affichant la liste des ports série pour une sélection par l'utilisateur.

<source lang=cpp>
import processing.serial.*;
import controlP5.*;
import java.util.Map;

Serial myPort; // Objet pour la liaison série
byte[] inBuffer = new byte[255];
String id[]=new String[4]; // Tableau d'identifiants
String mp[]=new String[4]; // Tableau de mot de passe
//parfois, un caractère apparaît au début de la chaîne de caractères transmis, la variable suivante permet d'adapter la lecture à cette erreur par un décallage
char dec=2; //si >=2 erreur, sinon indique le décalage nécessaire pour la lecture
int num; // Numéro du couple identifiant mot de passe

ControlP5 cp5; // Objet permettant l'ajout d'outils pour interfaces graphiques
boolean modif; // Drapeau indiquant la modification
boolean init; //attente de réception de données pour affichage
boolean finInit; // Drapeau pour vérifier la fin d'initialisation
int suppr=4; //compteur de tour pour suppression des cadres
PFont font = createFont("arial", 20);

void setup() {

modif=false;
size(600, 600);
cp5 = new ControlP5(this);
myPort=new Serial(this, Serial.list()[0], 9600);

init=true;
finInit=false;
demande();
}

/********************
* partie affichage *
********************/

void draw() {
lecture();
decor();
if (finInit==true) afficher();
}

/*FONCTION POUR AFFICHER LA LISTE DES IDENTIFIANTS ET LE BOUTON MODIFIER*/
void afficher() {
init=false;
finInit=false;
cp5.addScrollableList("Identifiants") //création de la liste des identifiants
.setPosition(220, 100)
.setSize(200, 200)
.setBarHeight(30)
.setItemHeight(25)
.addItems(id)
.setColorBackground(color(155, 75, 80));

cp5.addButton("Modifier") //création du bouton bouton modifier
.setPosition(440, 100)
.setSize(100, 30)
.setColorBackground(color(155, 75, 80));
}

/*FONCTION POUR AFFICHER LE FOND*/
void decor() {
background(100);
fill(255);
textSize(25);
text("Réglage de la clé USB", 160, 60);
textSize(15);
text("Choix de l'identifiant :", 50, 120);
if (modif==true) { //S'affiche quand la modification est activée
text("Identifiant :", 100, 270);
text("Mot de passe :", 100, 320);
text("Confirmation :", 100, 370);
} else if (suppr<4) {
/*un délai est nécessaire entre deux suppressions donc on supprime un cadre par image affichée*/
switch(suppr) {
case 0:
cp5.remove("id");
break;
case 1:
cp5.remove("mp");
break;
case 2:
cp5.remove("cf");
break;
case 3:
cp5.remove("Valider");
break;
}
suppr++;
}
}

/*Interuption declenchée lors de la séléction d'un élément de la liste */
void Identifiants(int n) {
num=n;
}

/*Interruption déclenchée lors de l'appui sur le bouton modifier */
void Modifier() {
modif=true;

cp5.addTextfield("id") //création de la fenêtre de saisie pour identifiant
.setPosition(220, 250)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
;

cp5.addTextfield("mp") //création de la fenêtre de saisie pour mot de passe
.setPosition(220, 300)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true) //mode mot de passe (affichage d’étoile à la place des caractères)
;

cp5.addTextfield("cf") //création de la fenêtre de saisie pour confirmation du mot de passe
.setPosition(220, 350)
.setSize(200, 30)
.setFont(font)
.setFocus(true)
.setAutoClear(false)
.setColor(color(255))
.setPasswordMode(true)
;

cp5.addButton("Valider") //création du bouton valider
.setPosition(220, 400)
.setSize(200, 25)
;
}

/*Interuption declenchée lors de l'appui sur le boutton valider */
public void Valider() {
/*Pour valider, il faut qu'il ait au moins un caractère de saisie dans les partie identifiant et mot de passe*/
if ((cp5.get(Textfield.class, "id").getStringValue() != "") && (cp5.get(Textfield.class, "mp").getStringValue() != "")) {
println(cp5.get(Textfield.class, "id").getStringValue()+'\n'+cp5.get(Textfield.class, "mp").getStringValue()+'\n'+cp5.get(Textfield.class, "cf").getStringValue());

/*Test pour vérifier qu'on à la même chaîne de caractère dans les fenêtre mot de passe et confirmation */
if (cp5.get(Textfield.class, "mp").getStringValue().equals(cp5.get(Textfield.class, "cf").getStringValue()) == true ) {
println("OK");
id[num]=cp5.get(Textfield.class, "id").getStringValue();
mp[num]=cp5.get(Textfield.class, "mp").getStringValue();
cp5.get(ScrollableList.class, "Identifiants").setItems(id);
suppr=0;
modif=false;

changer(num);
demande();
}
}
}

/************************
* partie communication *
************************/

//demande mp
void demande() {
myPort.write("1"+'\n');
}

//envoie nouveau mp
void changer(int num) {
myPort.write("2"+'\n'+num+'\n'+id[num]+'\n'+mp[num]+'\n');

}

void lecture() {
char I[]=new char[16]; //chaîne de caractères reçus pour l’identifiant, sera converti en String après traitement
char M[]=new char[16]; //chêne de caractères reçus pour le mot de passe

if (dec<2) {
int i=dec+2; //apres 3\n

for (int j=0; j<4; j++) {
int k=0;
i+=2; //apres 3 \n num \n
//lecture de l'identifiant i
do {
I[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
id[j]=new String(I);
i++;
k=0;

//lecture du mot de passe i
do {
M[k]=char(inBuffer[i]);
i++;
k++;
}
while ( (inBuffer[i]!='\n')&&(k<15));
mp[j]=new String(M);
i++;
}
if(init==false) cp5.get(ScrollableList.class, "Identifiants").setItems(id); //si la liste d'identifiant existe on la met à jour
else finInit=true; //sinon on autorise la création de la liste
dec=2;
}
}

void serialEvent(Serial myPort) {
println("reçu");
myPort.readBytesUntil(0x0d, inBuffer);

if (inBuffer != null) {
if (inBuffer[0]=='3') {
dec=0;
} else if (inBuffer[1] == '3') { //si le début du signal est décalé d'un octet
dec=1;
} else dec =2;
/*si le décalage est plus grand, on considère que c'est une erreur car il y a de forte chance que le
signal ne corresponde pas à celui attendu et que la présence de la consigne 3 ne soit qu'une coïncidence*/
}
}
</source>
{{boîte déroulante/fin}}

={{Rouge|Troisième clé USB}}=
La carte suivante est une version améliorée de la clé précédente. Le schéma reste le même, mais le routage a été amélioré afin de faciliter la fabrication (via plus espacés), et d'inclure un anneau pour fixer un porte clé.

=={{Bleu|Conception de la troisième carte}}==

{|
|-
| [[Image:USB3_board.png|vignette|upright=2|Board]] || [[Image:USB3_percage.png|vignette|upright=2|Perçage]]
|-
| [[Image:USB3_composants_top.png|vignette|upright=2|Composants top]] || [[Image:USB3_composants_bottom.png|vignette|upright=2|Composants bottom]]
|}

=={{Bleu|Conception d'un boitier pour la clé}}==

Fichier:USB3 composants bottom.png

2016-03-25T17:44:29Z

Cleusb :

Fichier:USB3 composants top.png

2016-03-25T17:44:07Z

Cleusb :