Utiliser les fonctions Mouse et Keyboard AZERTY d’un Arduino Pro Micro

arduino leonardo

Comme nous l’avons vu dans un précédent article, l’Arduino Pro Micro est équipé d’un ATMega32U4 qui lui permet ainsi d’être reconnu comme un périphérique USB.

Cela signifie donc que vous pouvez utiliser un Arduino Pro Micro pour simuler des touches clavier ou un déplacement de souris.

Dans cet article nous allons voir comment utiliser la fonction Keyboard d’un microcontrôleur Arduino Pro Micro.

Enfin nous verrons une carte microcontrôleur prometteuse qui permet d’utiliser les fonctionnalités liées au clavier et à la souris: la Teensy.

Compatibilité des Arduino avec la librairie Keyboard et Mouse

Arduino met à notre disposition une page d’explication concernant l’utilisation de la librairie Keyboard et Mouse.

L’information principale qui en sort est que tous les microcontrôleurs Arduino ne peuvent pas utiliser cette librairie.

En effet, il faut obligatoirement un processeur ATMega32U4 qui gère 2 communications USB simultanément pour pouvoir utiliser la librairie KeyboardMouse. Cette librairie est donc réservée au Arduino Micro, Arduino Due ou bien encore au Arduino Leonardo.

Pour ceux qui n’auraient qu’un Arduino Uno sous la main, rassurez-vous il existe une librairie externe (V-USB) qui permet de faire la même chose (nous le verrons peut être dans un autre article).

Arduino et Keyboard

Les fonctions Keyboard permettent de contrôler votre clavier directement à partir de votre carte contrôleur Arduino:

  • Keyboard.begin: démarre l’utilisation de la librairie Keyboard
  • Keyboard.end: arrête l’utilisation de la librairie Keyboard
  • Keyboard.press: émule l’enfoncement d’une touche clavier
  • Keyboard.print: envoie la valeur d’une touche clavier
  • Keyboard.println: envoie la valeur d’une touche clavier suivi d’un retour à la ligne
  • Keyboard.release: émule le relachement d’une touche clavier
  • Keyboard.releaseAll: émule le relachement de toutes les touches clavier
  • Keyboard.write: permet d’écrire un texte en émulant la saisie au clavier

Arduino et Mouse

Les fonctions Mouse permettent de contrôler votre souris directement à partir de votre carte contrôleur Arduino:

  • Mouse.begin: démarre l’utilisation de la librairie Mouse
  • Mouse.click: émule un clic souris
  • Mouse.end: arrête l’utilisation de la librairie Mouse
  • Mouse.move: émule un déplacement du curseur
  • Mouse.press: émule l’enfoncement du bouton gauche de votre souris
  • Mouse.release: émule le relachement du bouton gauche de votre souris
  • Mouse.isPressed: permet de détecter sur le clic gauche de votre souris est pressé

Exemple complet Arduino et Keyboard

Bon j’avoue sur ce coup la je me suis pas foulé, j’ai pris l’exemple fourni par Arduino. Mais j’ai une bonne raison: l’exemple est simple à comprendre, nécessite peu de composants électroniques et montre comment utiliser la librairie Mouse et la librairie Keyboard avec un Arduino Leonardo.

Pour chaque bouton est associé un déplacement de souris et une touche clavier.

Arduino KeyboardMouse Exemple

Arduino KeyboardMouse Exemple

Téléchargez le sketch suivant sur votre Arduino Leonardo (ou Arduino Pro Micro), ouvrez un éditeur de texte puis appuyez sur les boutons. Vous verrez alors votre souris bouger et des lettres s’ajouter dans le fichier.

// set pin numbers for the five buttons:
const int upButton = 2;    
const int downButton = 3;        
const int leftButton = 4;
const int rightButton = 5;
const int mouseButton = 6;
 
void setup() { // initialize the buttons' inputs:
  pinMode(upButton, INPUT);      
  pinMode(downButton, INPUT);      
  pinMode(leftButton, INPUT);      
  pinMode(rightButton, INPUT);      
  pinMode(mouseButton, INPUT);
 
  Serial.begin(9600);
  // initialize mouse control:
  Mouse.begin();
  Keyboard.begin();
}
 
void loop() {
  // use serial input to control the mouse:
  if (Serial.available() > 0) {
    char inChar = Serial.read();
 
    switch (inChar) {  
    case 'u':
      // move mouse up
      Mouse.move(0, -40);
      break;
    case 'd':
      // move mouse down
      Mouse.move(0, 40);
      break;
    case 'l':
      // move mouse left
      Mouse.move(-40, 0);
      break;
    case 'r':
      // move mouse right
      Mouse.move(40, 0);
      break;
    case 'm':
      // perform mouse left click
      Mouse.click(MOUSE_LEFT);
      break;
    }
  }
 
  // use the pushbuttons to control the keyboard:
  if (digitalRead(upButton) == HIGH) {
    Keyboard.write('u');
  }
  if (digitalRead(downButton) == HIGH) {
    Keyboard.write('d');
  }
  if (digitalRead(leftButton) == HIGH) {
    Keyboard.write('l');
  }
  if (digitalRead(rightButton) == HIGH) {
    Keyboard.write('r');
  }
  if (digitalRead(mouseButton) == HIGH) {
    Keyboard.write('m');
  }
}

Arduino Keyboard et AZERTY

Nous arrivons enfin à ce qui m’a amené à écrire cet article: la librairie Keyboard utilisée par Arduino utilise un clavier QWERTY.

Cela signifie donc que si vous faites:

Keyboard.write("azerty");

Vous verrez s’afficher à l’écran:

qwerty

Et c’est compréhensible car si l’on regarde de plus prêt le code de la librairie Keyboard qui est disponible dans le fichier “hardware\arduino\cores\arduino\HID.cpp”, alors on se rend compte que le mapping des touches se fait via le code de la touche clavier.

L’image suivante (prise sur wikiversity) illustre la différence entre un clavier USB QWERTY et un clavier AZERTY:

Arduino Keyboard QWERTY AZERTY

Arduino Keyboard QWERTY AZERTY

La définition incluse dans le fichier HID.cpp est la définition d’un clavier QWERTY et elle se trouve dans la variable “_asciimap”:

const uint8_t _asciimap[128] =
{
	0x00,             // NUL
	0x00,             // SOH
	0x00,             // STX
	0x00,             // ETX
	0x00,             // EOT
	0x00,             // ENQ
	0x00,             // ACK  
	0x00,             // BEL
	0x2a,			// BS	Backspace
	0x2b,			// TAB	Tab
	0x28,			// LF	Enter
	0x00,             // VT 
	0x00,             // FF 
	0x00,             // CR 
	0x00,             // SO 
	0x00,             // SI 
	0x00,             // DEL
	0x00,             // DC1
	0x00,             // DC2
	0x00,             // DC3
	0x00,             // DC4
	0x00,             // NAK
	0x00,             // SYN
	0x00,             // ETB
	0x00,             // CAN
	0x00,             // EM 
	0x00,             // SUB
	0x00,             // ESC
	0x00,             // FS 
	0x00,             // GS 
	0x00,             // RS 
	0x00,             // US 
 
	0x2c,		   //  ' '
	0x1e|SHIFT,	   // !
	0x34|SHIFT,	   // "
	0x20|SHIFT,    // #
	0x21|SHIFT,    // $
	0x22|SHIFT,    // %
	0x24|SHIFT,    // &
	0x34,          // '
	0x26|SHIFT,    // (
	0x27|SHIFT,    // )
	0x25|SHIFT,    // *
	0x2e|SHIFT,    // +
	0x36,          // ,
	0x2d,          // -
	0x37,          // .
	0x38,          // /
	0x27,          // 0
	0x1e,          // 1
	0x1f,          // 2
	0x20,          // 3
	0x21,          // 4
	0x22,          // 5
	0x23,          // 6
	0x24,          // 7
	0x25,          // 8
	0x26,          // 9
	0x33|SHIFT,      // :
	0x33,          // ;
	0x36|SHIFT,      // <
	0x2e,          // =
	0x37|SHIFT,      // >
	0x38|SHIFT,      // ?
	0x1f|SHIFT,      // @
	0x04|SHIFT,      // A
	0x05|SHIFT,      // B
	0x06|SHIFT,      // C
	0x07|SHIFT,      // D
	0x08|SHIFT,      // E
	0x09|SHIFT,      // F
	0x0a|SHIFT,      // G
	0x0b|SHIFT,      // H
	0x0c|SHIFT,      // I
	0x0d|SHIFT,      // J
	0x0e|SHIFT,      // K
	0x0f|SHIFT,      // L
	0x10|SHIFT,      // M
	0x11|SHIFT,      // N
	0x12|SHIFT,      // O
	0x13|SHIFT,      // P
	0x14|SHIFT,      // Q
	0x15|SHIFT,      // R
	0x16|SHIFT,      // S
	0x17|SHIFT,      // T
	0x18|SHIFT,      // U
	0x19|SHIFT,      // V
	0x1a|SHIFT,      // W
	0x1b|SHIFT,      // X
	0x1c|SHIFT,      // Y
	0x1d|SHIFT,      // Z
	0x2f,          // [
	0x31,          // bslash
	0x30,          // ]
	0x23|SHIFT,    // ^
	0x2d|SHIFT,    // _
	0x35,          // `
	0x04,          // a
	0x05,          // b
	0x06,          // c
	0x07,          // d
	0x08,          // e
	0x09,          // f
	0x0a,          // g
	0x0b,          // h
	0x0c,          // i
	0x0d,          // j
	0x0e,          // k
	0x0f,          // l
	0x10,          // m
	0x11,          // n
	0x12,          // o
	0x13,          // p
	0x14,          // q
	0x15,          // r
	0x16,          // s
	0x17,          // t
	0x18,          // u
	0x19,          // v
	0x1a,          // w
	0x1b,          // x
	0x1c,          // y
	0x1d,          // z
	0x2f|SHIFT,    // 
	0x31|SHIFT,    // |
	0x30|SHIFT,    // }
	0x35|SHIFT,    // ~
	0				// DEL
};

Si vous souhaitez donc utiliser votre Arduino avec les fonctions Keyboard AZERTY, il vous faudra remplacer la définition QWERTY des touches précédentes (dans fichier HID.cpp) par la définition AZERTY suivante:

const uint8_t _asciimap[128] =
{
	0x00,             // NUL
	0x00,             // SOH
	0x00,             // STX
	0x00,             // ETX
	0x00,             // EOT
	0x00,             // ENQ
	0x00,             // ACK  
	0x00,             // BEL
	0x2a,			// BS	Backspace
	0x2b,			// TAB	Tab
	0x28,			// LF	Enter
	0x00,             // VT 
	0x00,             // FF 
	0x00,             // CR 
	0x00,             // SO 
	0x00,             // SI 
	0x00,             // DEL
	0x00,             // DC1
	0x00,             // DC2
	0x00,             // DC3
	0x00,             // DC4
	0x00,             // NAK
	0x00,             // SYN
	0x00,             // ETB
	0x00,             // CAN
	0x00,             // EM 
	0x00,             // SUB
	0x00,             // ESC
	0x00,             // FS 
	0x00,             // GS 
	0x00,             // RS 
	0x00,             // US 
 
	0x2c,		   //  ' '
	0x38,	   // ! 
	0x20,    // "
	0x20,    // # :TODO
	0x30,    // $
	0x34|SHIFT,    // %
	0x1E,    // & 
	0x21,          // '
	0x22,    // (
	0x2d,    // )
        0x31,    // * : done
	0x2b|SHIFT,    // +
	0x10,          // , 
	0x23,          // -
	0x36|SHIFT,    // .
	0x37|SHIFT,    // /
	0x27|SHIFT,    // 0
	0x1e|SHIFT,    // 1
	0x1f|SHIFT,    // 2
	0x20|SHIFT,    // 3
	0x21|SHIFT,    // 4
	0x22|SHIFT,    // 5
	0x23|SHIFT,    // 6
	0x24|SHIFT,    // 7
	0x25|SHIFT,    // 8
	0x26|SHIFT,    // 9
	0x37,          // :
	0x36,          // ;
	0x64,      // < Done
	0x2e,          // =
	0x64|SHIFT,      // > Done
	0x10|SHIFT,      // ? 0x38 -> 0x10 OK
	0x1f,      // @ TODO
	0x14|SHIFT,      // A
	0x05|SHIFT,      // B
	0x06|SHIFT,      // C
	0x07|SHIFT,      // D
	0x08|SHIFT,      // E
	0x09|SHIFT,      // F
	0x0a|SHIFT,      // G
	0x0b|SHIFT,      // H
	0x0c|SHIFT,      // I
	0x0d|SHIFT,      // J
	0x0e|SHIFT,      // K
	0x0f|SHIFT,      // L
	0x33|SHIFT,      // M
	0x11|SHIFT,      // N
	0x12|SHIFT,      // O
	0x13|SHIFT,      // P
	0x04|SHIFT,      // Q
	0x15|SHIFT,      // R
	0x16|SHIFT,      // S
	0x17|SHIFT,      // T
	0x18|SHIFT,      // U
	0x19|SHIFT,      // V
	0x1d|SHIFT,      // W
	0x1b|SHIFT,      // X
	0x1c|SHIFT,      // Y
	0x1a|SHIFT,      // Z
	0x0c,          // [ TODO 2F
	0x31,          // bslash
	0x0d,          // ] TODO 30
	0x2F,    // ^
	0x25,    // _
	0x35,          // ` TODO
	0x14,          // a
	0x05,          // b
	0x06,          // c
	0x07,          // d
	0x08,          // e
	0x09,          // f
	0x0a,          // g
	0x0b,          // h
	0x0c,          // i
	0x0d,          // j
	0x0e,          // k
	0x0f,          // l
	0x33,          // m
	0x11,          // n
	0x12,          // o
	0x13,          // p
	0x04,          // q
	0x15,          // r
	0x16,          // s
	0x17,          // t
	0x18,          // u
	0x19,          // v
	0x1d,          // w
	0x1b,          // x
	0x1c,          // y
	0x1a,          // z
	0x2f|SHIFT,    // 
	0x31|SHIFT,    // | TODO
	0x30|SHIFT,    // } TODO
	0x35|SHIFT,    // ~ TODO
	0				// DEL
};

Le souci avec le code Keyboard AZERTY précédent est qu’il ne gère pas tous les caractères. Actuellement il supporte les caractères suivant: “abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\”$%&'()%,;:!?./+=”.

J’ai cherché une solution simple pour être capable de restituer n’importe quelle touche clavier, mais je n’ai pas trouvé d’informations la dessus.

Microcontrôleur Teensy

Le microcontrôleur Teensy semble être une très bonne alternative aux Arduino Micro ou Arduino Leonardo. Il propose les mêmes fonctionnalités qu’un Arduino Leonardo (et même des fonctionnalités supplémentaires) en étant beaucoup plus compact.

teensy 3

teensy 3

Voici les avantages du Teensy:

  • La carte est reconnue nativement comme un périphérique USB
  • Processeur AVR cadencé à 16 MHz
  • Facilité d’utilisation
  • Outil de développement gratuit
  • Compatible Windows, Linux et Macintosh
  • Format réduit pour une utilisation embarquée dans toute sorte de projets
  • Prix réduit
wiring pinout teensy

wiring pinout teensy

Différences entre Teensy et Arduino

Le développement de la carte Teensy a démarré avant la sortie des Arduino à base de processeur ATMEGA32U4, c’est pourquoi actuellement aucune carte Arduino n’offre les mêmes fonctionnalités que la carte Teensy++ (à partir de la 2.0).

Ainsi les deux cartes supportent le port série via USB, les librairies Keyboard et Mouse mais il existe des différences majeures. Voici les spécifications entre la Teensy 2.0 (valable également pour la Teensy 3) et la carte Arduino Leonardo.

Teensy 2.0

  • Support du MIDI, Disque externe, Joystick, RawHID, Manettes et autres pads via le port USB.
  • Opérations optimisées: digitalWrite, digitalRead, pinMode, …
  • 3.5K d’espace eeprom disponible (bootloader optimisé et taille réduite)
  • Support des claviers USB: détection AZERTY / QWERTY / Locales
  • Carte au format réduit (proche d’un Arduino Pro Micro)
  • Pas d’installation de driver nécessaire pour utilisée la carte

Arduino Leonardo

  • Supporte des sources de courant non régulée (jusqu’à 9V), ce qui facilite l’utilisation de sources externes d’énergie (batteries, piles, solaire, …)
  • Sélection automatique de la source d’énergie (USB ou VCC ou RAW)
  • Format de carte identique à un Arduino Uno permettant l’utilisation de certains shields.
  • Hardware cloning autorisé, ce qui permet de trouver des clones à pas cher sur Ebay :p

En espérant que cet article vous aidera dans vos projets à base de Teensy ou Arduino Pro Micro utilisant les librairies Keyboard et Mouse 🙂

16 Responses to Utiliser les fonctions Mouse et Keyboard AZERTY d’un Arduino Pro Micro

  1. Fatma says:

    J’ai utilisé la définition incluse dans le fichier HID.cpp que vous avez écrit ci-dessus mais je rencontre toujours le même problème ( le A qui s’affiche Q e le Z en W) .Dois-je ajouter une déclaration dans mon code ?

  2. FHT says:

    Bravo pour le travail !
    Petite question :
    a la ligne de Prog :

    Keyboard.write(“azerty”);—> moi ca compile pas

    ce serait pas ca plutôt ?
    Keyboard.print (“azerty”);

  3. PowerKx says:

    pour toute les autres touche du clavier 😉

    http://arduino.cc/en/Reference/KeyboardModifiers

  4. Cédric says:

    Nickel ton article, tu m’as bien aidé.
    J’ai vu un petit problème pour le caractère ‘+’. Le code AZERTY est bien 0x2e|SHIFT comme en QWERTY (on le voit sur tes images de clavier). Dans ton code, tu l’avais mis à 0x2b|SHIFT.

    Encore merci.

  5. JackyDeNice says:

    Bonjour,
    J’ai besoin de créer un clavier complet avec des boutons qui se trouvent éparpillés sur une plaque. Est-ce réalisable et si oui quelqu’un peut-il m’aider car je n’ai aucune connaissance avec ARDUINO.
    Merci de vos réponses

  6. Bapt1080 says:

    Merci bcp pour l’_asciimap azerty!!! j’ai cru que j’allais tous me les taper à la main 😉 . Bon boulot!
    Par contre si tu trouves la solution pour avoir une keymap complete azerty je suis preneur, j’ai beau tout retourner, impossible de générer un # par exemple (j’ai balcé tous les codes touches de 0 jusqu’à 400, ça tourne en boucle après et jamais de #…), il doit y avoir une histoire de key modifier….

    • jhd says:

      Pour le diese et certains autres caractères j’avais été ennuyé également. Malheureusement je ne me souviens plus comment j’ai fait. Je vais regarder dans mes archives de code ce week end.

  7. kruch says:

    Je suis a la version 1.6.8 est le variable const uint8_t _asciimap[128] ne se trouve plus dans HID.cpp mais dans Arduino\libraries\Keyboard\src\keyboard.cpp

  8. zs says:

    Bonjour
    avez vous une solution pour le caractère “\”

    Merci

  9. Paul says:

    Bonjour,

    J’essaye d’utiliser votre code afin d’utiliser une carte leonardo pro micro en tant que clavier mais j’ai une erreur de définition de SHIFT(not defined in this scope)

    Pourriez vous m’expliquer votre démarche plus en détails.
    Merci

Leave a Reply

Your email address will not be published. Required fields are marked *