press(...) release(...)

Parent Previous Next


Fonctions:

press ( char c )                        // un char représentant un nombre de '0' à '9' ainsi que '+'  '-'  '/'  '*'  '\r'

press( char tableau[] )                // Seul le premier caractère est pris en compte.

press( String S )                        // Seul le premier caractère est pris en compte.

                       

press( valeur numérique )                // valeur de 0 à 9 et 13 (return).


release( char c )                        // un char représentant un nombre de '0' à '9' ainsi que '+'  '-'  '/'  '*'  '\r'

release( char tableau[] )                // Seul le premier caractère est pris en compte.

release( String S )                        // Seul le premier caractère est pris en compte.


release( valeur numérique )                // valeur de 0 à 9 et 13 (return).


Description:

       Permet l'appui ou le relâchement d'une touche correspondant à un caractère au format UTF8 (ASCII compatible)

       (L'IDE d'Arduino utilise le codage des caractères au format UTF8)


Arguments:

       Un char, un tableau de char, une chaîne de caractères String ou une valeur numérique (Byte)


Valeur de retour:

Retourne 1 si la fonction réussie et en cas d'erreur renvoie 0.



Exemple:

       KeyboardEx.press('A')                // pour un char (1 seul octet)

       KeyboardEx.release('A')


       KeyboardEx.press("@");                // un caractère sous forme de tableau (peut contenir un caractère sur plusieurs octets)

       KeyboardEx.release("@");        


KeyboardEx.press("Arduino");        // seul le premier caractère est pris en compte dans ce cas

       KeyboardEx.release("Arduino");



Code:


#include "keyboardEx.h"


void setup() {

 KeyboardEx.begin();

 // KeyboardEx.setOS(Windows); // Si vous êtes sur Windows, permet l'utilisation des Alt Codes.

 // KeyboardEx.setDelay(5); // valeur par défaut, si problème augmenter la valeur à 10.

 Serial.begin(115200);

 while (!Serial) {

   ; // wait for serial port to connect. Needed for native USB

 }

 delay(6000);

}


void loop() {

 byte ret = 1;

#include "Adafruit_TinyUSB.h"

#include "KeyboardEx.h"


// Report ID

enum

{

 RID_KEYBOARD = 1,

 // RID_MOUSE,

 RID_CONSUMER_CONTROL, // Media, volume etc ..

};


// HID report descriptor using TinyUSB's template

uint8_t const desc_hid_report[] =

{

 //TUD_HID_REPORT_DESC_KEYBOARD(),

 TUD_HID_REPORT_DESC_KEYBOARD( HID_REPORT_ID(RID_KEYBOARD) ),

 //TUD_HID_REPORT_DESC_MOUSE   ( HID_REPORT_ID(RID_MOUSE) ),

 TUD_HID_REPORT_DESC_CONSUMER( HID_REPORT_ID(RID_CONSUMER_CONTROL) )

};


Adafruit_USBD_HID usb_hid;

// --------------------------------------------------------------------------


void setup() {

 usb_hid.setPollInterval(2);

 usb_hid.setReportDescriptor(desc_hid_report, sizeof(desc_hid_report));

 usb_hid.setReportCallback(get_report_callback , hid_report_callback);


 usb_hid.begin();

 KeyboardEx.begin(usb_hid, RID_KEYBOARD);


 KeyboardEx.setOS(Windows); // Si vous êtes sur Windows, permet l'utilisation des Alt Codes.

 // KeyboardEx.setDelay(5); // valeur par défaut, si problème augmenter la valeur à 10.


 // Commenter ces lignes si vous n'utilisez oas le port série

 Serial.begin(115200);

 while (!Serial) {

   ; // wait for serial port to connect. Needed for native USB

 }

 delay(6000);

}


void loop() {

 static int oneloop = 0;

 unsigned int totalCaractere;

 byte ret = 1;


 // n'aime pas le while(1)

 if (!oneloop) {

   oneloop = 1;

   // ******************************************************************************************************

   //  Test de la fonction -> KeyboardEx.press(...) , KeyboardEx.release(...)

   // ******************************************************************************************************

   KeyboardEx.println(F("*** Test de la fonction -> KeyboardEx.press(...) , KeyboardEx.release(...) ***"));


   const char texte1[] = {"Cla"};

   for (unsigned int i = 0; i < strlen(texte1); i++) {

     ret &= KeyboardEx.press(texte1 + i);

     delay(1000);

     ret &= KeyboardEx.release(texte1 + i);

     ret &= KeyboardEx.println();

     // La fonction setAlign va corriger l'incrémentation de la variable i

     // nécessaire à cause du format UTF8

     // Normalement la fonction s'utilise au début de la boucle

     // pour récupérer les informations sur le caractère avant traitement

     // mais seul la correction de la variable i nous intéresse ici.

     KeyboardEx.setAlign(texte1, i);

   }


   char texte2[] = {"vier"};

   for (unsigned int i = 0; i < strlen(texte2); i++) {

     ret &= KeyboardEx.press(texte2 + i);

     delay(1000);

     ret &= KeyboardEx.release(texte2 + i);

     ret &= KeyboardEx.println();

     KeyboardEx.setAlign(texte2, i);

   }


   const String texte3 = {"Fran"};

   for (unsigned int i = 0; i < texte3.length(); i++) {

     ret &= KeyboardEx.press(texte3.substring(i));

     delay(1000);

     ret &= KeyboardEx.release(texte3.substring(i));

     ret &= KeyboardEx.println();

     KeyboardEx.setAlign(texte3, i);

   }


   String texte4 = {"çais"};

   for (unsigned int i = 0; i < texte4.length(); i++) {

     ret &= KeyboardEx.press(texte4.substring(i));

     delay(1000);

     ret &= KeyboardEx.release(texte4.substring(i));

     ret &= KeyboardEx.println();

     KeyboardEx.setAlign(texte4, i);

   }


   ret &= KeyboardEx.press('A'); // le char ne fonctionne que pour les caractères ASCII de 0 à 127

   delay(1000);

   ret &= KeyboardEx.release('A');

   ret &= KeyboardEx.println();


   ret &= KeyboardEx.press("î"); // donne îiiiiiiiiiiiiii ce qui donne le même résultat que si on le fait au clavier!

   delay(1000);

   ret &= KeyboardEx.release("î");

   ret &= KeyboardEx.println(); // ou KeyboardEx.write(TINY_KEY_RETURN);


   ret &= KeyboardEx.press("@");

   delay(1000);

   ret &= KeyboardEx.release("@");

   ret &= KeyboardEx.println();


   ret &= KeyboardEx.press("ç");

   delay(1000);

   ret &= KeyboardEx.release("ç");

   ret &= KeyboardEx.println();


   ret &= KeyboardEx.press('9');

   delay(1000);

   ret &= KeyboardEx.release('9');

   ret &= KeyboardEx.println();


   ret &= KeyboardEx.press(9);

   delay(1000);

   ret &= KeyboardEx.release(9);

   ret &= KeyboardEx.println();


   KeyboardEx.print("Valeur de retour: ");

   KeyboardEx.println(ret);


   KeyboardEx.end();

 }

}



uint16_t get_report_callback (uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen)

{

 // Mettre Null à la place de get_report_callback dans cette fonction ci- dessous déclarée plus haut

 // si vous souhaitez supprmer cette procédure

 // usb_hid.setReportCallback(get_report_callback , hid_report_callback) -> usb_hid.setReportCallback(Null , hid_report_callback);


 // not used in this example

 return 0;

}


// Output report callback for LED indicator such as Caplocks

void hid_report_callback(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize)

{

 uint8_t ledIndicator;


 // LED indicator is output report with only 1 byte length

 if ( report_type != HID_REPORT_TYPE_OUTPUT ) return;

 // KEYBOARD_LED_KANA (8) | KEYBOARD_LED_COMPOSE (3) | KEYBOARD_LED_SCROLLLOCK (4) | KEYBOARD_LED_CAPSLOCK (2) | KEYBOARD_LED_NUMLOCK (1)


 // buffer[0] si clavier seul

 // ou buffer[1] si plusieurs reports

 if (bufsize == 2) {

   ledIndicator = buffer[1];

 } else {

   ledIndicator = buffer[0];

 }

 // Allumer la led de la carte si CAPSLOCK (verrouillage des majuscule) est activé

 // La led ne s'allumera pas sur Adafruit QT py car c'est une Neopixel

 // mais sur un Seeeduino XIAO ok

 digitalWrite(LED_BUILTIN, !(ledIndicator & KEYBOARD_LED_CAPSLOCK));

}

 while (1);

}




#include "Adafruit_TinyUSB.h"

#include "KeyboardEx.h"


// Report ID

enum

{

 RID_KEYBOARD = 1,

 // RID_MOUSE,

 RID_CONSUMER_CONTROL, // Media, volume etc ..

};


// HID report descriptor using TinyUSB's template

uint8_t const desc_hid_report[] =

{

 //TUD_HID_REPORT_DESC_KEYBOARD(),

 TUD_HID_REPORT_DESC_KEYBOARD( HID_REPORT_ID(RID_KEYBOARD) ),

 //TUD_HID_REPORT_DESC_MOUSE   ( HID_REPORT_ID(RID_MOUSE) ),

 TUD_HID_REPORT_DESC_CONSUMER( HID_REPORT_ID(RID_CONSUMER_CONTROL) )

};


Adafruit_USBD_HID usb_hid;

// --------------------------------------------------------------------------


const char texte_C_string[] = {"Article à 12€ en ce moment!"};

String texte_String = {"Arduino"};



void setup() {

 usb_hid.setPollInterval(2);

 usb_hid.setReportDescriptor(desc_hid_report, sizeof(desc_hid_report));

 usb_hid.setReportCallback(get_report_callback , hid_report_callback);


 usb_hid.begin();

 KeyboardEx.begin(usb_hid, RID_KEYBOARD);


 KeyboardEx.setOS(Windows); // Si vous êtes sur Windows, permet l'utilisation des Alt Codes.

 // KeyboardEx.setDelay(5); // valeur par défaut, si problème augmenter la valeur à 10.


 // Commenter ces lignes si vous n'utilisez oas le port série

 Serial.begin(115200);

 while (!Serial) {

   ; // wait for serial port to connect. Needed for native USB

 }

 delay(6000);

}


void loop() {

 static int oneloop = 0;

 unsigned int totalCaractere;

 byte ret = 1;


 // n'aime pas le while(1)

 if (!oneloop) {

   oneloop = 1;

   // ******************************************************************************************************

   //  Test de la fonction -> KeyboardEx.press(...) , KeyboardEx.release(...)

   // ******************************************************************************************************

   KeyboardEx.println(F("*** Test de la fonction -> KeyboardEx.press(...) , KeyboardEx.release(...) ***"));


   for (unsigned int i = 0; i < strlen(texte_C_string); i++) {

     if (KeyboardEx.setAlign(texte_C_string, i)) {

       const char* character = KeyboardEx.getCharacter();


       if (KeyboardEx.isLayout()) { // Correspond à une touche du clavier

         ret &= KeyboardEx.press(character);

         delay(1000);

         ret &= KeyboardEx.release(character);

         ret &= KeyboardEx.println();

       }

     } else {

       // Erreur, sortir immédiatement

       break;

     }

   }


   ret &= KeyboardEx.println();


   for (unsigned int i = 0; i < texte_String.length(); i++) {

     if (KeyboardEx.setAlign(texte_String.c_str(), i)) {

       const char* character = KeyboardEx.getCharacter();


       if (KeyboardEx.isLayout()) { // Correspond à une touche du clavier

         ret &= KeyboardEx.press(character);

         delay(1000);

         ret &= KeyboardEx.release(character);

         ret &= KeyboardEx.println();

       }

     } else {

       // Erreur, sortir immédiatement

       break;

     }

   }


   KeyboardEx.print("Valeur de retour: ");

   KeyboardEx.println(ret);


   KeyboardEx.end();

 }

}



uint16_t get_report_callback (uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen)

{

 // Mettre Null à la place de get_report_callback dans cette fonction ci- dessous déclarée plus haut

 // si vous souhaitez supprmer cette procédure

 // usb_hid.setReportCallback(get_report_callback , hid_report_callback) -> usb_hid.setReportCallback(Null , hid_report_callback);


 // not used in this example

 return 0;

}


// Output report callback for LED indicator such as Caplocks

void hid_report_callback(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize)

{

 uint8_t ledIndicator;


 // LED indicator is output report with only 1 byte length

 if ( report_type != HID_REPORT_TYPE_OUTPUT ) return;

 // KEYBOARD_LED_KANA (8) | KEYBOARD_LED_COMPOSE (3) | KEYBOARD_LED_SCROLLLOCK (4) | KEYBOARD_LED_CAPSLOCK (2) | KEYBOARD_LED_NUMLOCK (1)


 // buffer[0] si clavier seul

 // ou buffer[1] si plusieurs reports

 if (bufsize == 2) {

   ledIndicator = buffer[1];

 } else {

   ledIndicator = buffer[0];

 }

 // Allumer la led de la carte si CAPSLOCK (verrouillage des majuscule) est activé

 // La led ne s'allumera pas sur Adafruit QT py car c'est une Neopixel

 // mais sur un Seeeduino XIAO ok

 digitalWrite(LED_BUILTIN, !(ledIndicator & KEYBOARD_LED_CAPSLOCK));

}