KeyboardEx.h

Parent Previous Next

///// Keyboard modifier codes bitmap

//typedef enum

//{

//  KEYBOARD_MODIFIER_LEFTCTRL   = TU_BIT(0), ///< Left Control

//  KEYBOARD_MODIFIER_LEFTSHIFT  = TU_BIT(1), ///< Left Shift

//  KEYBOARD_MODIFIER_LEFTALT    = TU_BIT(2), ///< Left Alt

//  KEYBOARD_MODIFIER_LEFTGUI    = TU_BIT(3), ///< Left Window

//  KEYBOARD_MODIFIER_RIGHTCTRL  = TU_BIT(4), ///< Right Control

//  KEYBOARD_MODIFIER_RIGHTSHIFT = TU_BIT(5), ///< Right Shift

//  KEYBOARD_MODIFIER_RIGHTALT   = TU_BIT(6), ///< Right Alt

//  KEYBOARD_MODIFIER_RIGHTGUI   = TU_BIT(7)  ///< Right Window

//}hid_keyboard_modifier_bm_t;

//

//typedef enum

//{

//  KEYBOARD_LED_NUMLOCK    = TU_BIT(0), ///< Num Lock LED

//  KEYBOARD_LED_CAPSLOCK   = TU_BIT(1), ///< Caps Lock LED

//  KEYBOARD_LED_SCROLLLOCK = TU_BIT(2), ///< Scroll Lock LED

//  KEYBOARD_LED_COMPOSE    = TU_BIT(3), ///< Composition Mode

//  KEYBOARD_LED_KANA       = TU_BIT(4) ///< Kana mode

//}hid_keyboard_led_bm_t;



/*

* *********************************

  Nico78 - French Forum Arduino

* *********************************

  KeyboardEx.cpp Bêta 1

* *********************************

  Code permettant d'utiliser la langue française pour l'émulation du clavier sur Arduino

  Prend en charge tous les caractères du clavier physique, ainsi que les clés mortes (dead keys)

  soit l'ensemble des caractères suivant:

  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

  €£¤§¨°²µÀÂÃÄÈÊËÌÎÏÑÒÔÕÖÙÛÜàâãäçèéêëìîïñòôõöùûüÿ

*  * *********************************

 Copyright (c) 2015, Arduino LLC

 Original code (pre-library): Copyright (c) 2011, Peter Barrett

 This library is free software; you can redistribute it and/or

 modify it under the terms of the GNU Lesser General Public

 License as published by the Free Software Foundation; either

 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,

 but WITHOUT ANY WARRANTY; without even the implied warranty of

 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public

 License along with this library; if not, write to the Free Software

 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/


#ifndef KEYBOARDEX_h

#define KEYBOARDEX_h


#include <Arduino.h>

#include <avr/dtostrf.h>

#include "Adafruit_TinyUSB.h"


enum Keycode : uint8_t

{

 TINY_KEY_RESERVED = 0x00,


 TINY_KEY_RETURN = 0x28,

 TINY_KEY_ESCAPE,

 TINY_KEY_BACKSPACE ,

 TINY_KEY_TAB,

 TINY_KEY_SPACE,


 TINY_KEY_CAPS_LOCK = 0x39,

 TINY_KEY_F1,

 TINY_KEY_F2,

 TINY_KEY_F3,

 TINY_KEY_F4,

 TINY_KEY_F5,

 TINY_KEY_F6,

 TINY_KEY_F7,

 TINY_KEY_F8,

 TINY_KEY_F9,

 TINY_KEY_F10,

 TINY_KEY_F11,

 TINY_KEY_F12,

 TINY_KEY_PRINT_SCREEN,

 TINY_KEY_SCROLL_LOCK,

 TINY_KEY_PAUSE,

 TINY_KEY_INSERT,

 TINY_KEY_HOME,

 TINY_KEY_PAGE_UP,

 TINY_KEY_DELETE,

 TINY_KEY_END,

 TINY_KEY_PAGE_DOWN,

 TINY_KEY_ARROW_RIGHT,

 TINY_KEY_ARROW_LEFT,

 TINY_KEY_ARROW_DOWN,

 TINY_KEY_ARROW_UP,

 TINY_KEY_NUM_LOCK,

 TINY_KEY_KEYPAD_DIVIDE,

 TINY_KEY_KEYPAD_MULTIPLY,

 TINY_KEY_KEYPAD_SUBTRACT,

 TINY_KEY_KEYPAD_ADD,

 TINY_KEY_KEYPAD_ENTER,

 TINY_KEYPAD_1, // 89

 TINY_KEYPAD_2, // 90

 TINY_KEYPAD_3, // 91

 TINY_KEYPAD_4, // 92

 TINY_KEYPAD_5, // 93

 TINY_KEYPAD_6, // 94

 TINY_KEYPAD_7, // 95

 TINY_KEYPAD_8, // 96

 TINY_KEYPAD_9, // 97

 TINY_KEYPAD_0,  // 98

 TINY_KEY_KEYPAD_DECIMAL,


 TINY_KEY_APPLICATION = 0x65, //Menu

 TINY_KEY_POWER = 0x66,

 TINY_KEY_KEYPAD_EQUAL,

 

 TINY_KEY_F13 = 0x68,

 TINY_KEY_F14,

 TINY_KEY_F15,

 TINY_KEY_F16,

 TINY_KEY_F17,

 TINY_KEY_F18,

 TINY_KEY_F19,

 TINY_KEY_F20,

 TINY_KEY_F21,

 TINY_KEY_F22,

 TINY_KEY_F23,

 TINY_KEY_F24,

 

 TINY_KEY_CONTROL_LEFT = 0xe0,

 TINY_KEY_SHIFT_LEFT,

 TINY_KEY_ALT_LEFT,

 TINY_KEY_GUI_LEFT,

 TINY_KEY_CONTROL_RIGHT,

 TINY_KEY_SHIFT_RIGHT,

 TINY_KEY_ALT_RIGHT,

 TINY_KEY_GUI_RIGHT,

};

//================================================================================


enum _option : uint8_t

{

 _No_Return = 0,

 _Print = 0,

 _Keycode = 1,

 _Negatif = 1,

 _Press = 1,

 _Release = 2,

 _PressAndRelease = 3,

 _Return = 4,

 _Numerique = 16,

 _For_Print = 32,

 _For_AltCode = 64,

 _For_keypad = 128,

};


// définition du nombre de décimale par défaut

const uint8_t _nbdecimale = 2;


//  Low level key report: up to 6 keys and shift, ctrl etc at once

typedef struct

{

 uint8_t modifiers;

 uint8_t reserved;

 uint8_t keys[6];

} KeyReport;


// Système d'exploitation

enum _OS : uint8_t

{

 None,

 Windows,

 Linux,

 Mac,

};


//  informations envoyées lors de l'appel à getKeyEx

enum _keyEx : uint8_t

{

 keyEx_error = 0,         // si erreur

 keyEx_simpleKey = 1,     // si touche simple ou dead key seul

 keyEx_composeKey = 2,    // si touche composée

 keyEx_deadKey = 4,       // si dead key

 keyEx_isLayout = 8,      // le clavier le gère

};


//  stockage informations caractère utf8

typedef struct

{

 unsigned int isAsciiEx : 1;   // Figure dans la table Ascii éténdu, valeur 0 ou 1

 unsigned int isLayout : 1;    // Le clavier peut t'il l'afficher, valeur 0 ou 1

 unsigned int isDeadKey : 2;   // key1 est un dead key, valeur 0 si faux, 1 (dead key seul) ou 2 (dead key composé)

 unsigned int nbByte : 4;      // Nombre d'octets composant le caractère UTF8, valeur de 1 à 4 octets

 unsigned int asciiEx : 8;     // Valeur Ascii étendu du caractère UTF8 sur 8 Bit

 unsigned int key1 : 8;        // key1

 unsigned int key2 : 8;        // key2

 char  utf8[5];                // stockage du caractère UTF8

 char  copieUtf8[5];           // copie caractère UTF8

} infoUtf8;


class Keyboard_

{

 private:

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

   Adafruit_USBD_HID *_tinyUSB;

   uint8_t _ID_KEYBOARD;

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

   KeyReport _keyReport;

   uint8_t _tempo;

   uint8_t _NB_decimale;

   char _Notation_decimale;

   char _signPositif;

   char _prefix[3 + 1];

   infoUtf8 _infoUtf8;

   _OS OS;


   void sendReport(KeyReport* keys);


   uint8_t pressEx_(uint8_t k, const uint8_t option = 0);

   uint8_t releaseEx_(uint8_t k, const uint8_t option = 0);


   uint8_t isDeadKey_(const uint8_t k);

   uint8_t convertUtf8ToAscii_(const uint8_t &octets, const uint8_t* pointer);

   uint32_t UTF8_to_CodePoint_(const uint8_t *buffer, const size_t& size);


   size_t flashMemoryUTF8_(const __FlashStringHelper* ifsh, const uint8_t option = _For_Print);


   size_t setAlign_(const uint8_t* buffer, size_t& i);

   uint8_t printScancode_(const uint8_t& key1, const uint8_t& key2, const uint8_t option = _Print);

   size_t printAsciiBufferEx_(const uint8_t* buffer, const size_t& size, const uint8_t option = _Print);

   size_t printBuffer_(const uint8_t* buffer, const size_t& size, const uint8_t option = _Print);


   uint8_t altCP1252Win_(const uint8_t& asciiEx, const uint8_t option = _No_Return);

   uint8_t altcodePointWin_(const uint32_t& unicode, const uint8_t option = _No_Return);


   size_t altcodeBuffer_(const uint8_t *buffer, const size_t& size, const uint8_t option = _No_Return);

   size_t altcodeBufferEx_(const uint8_t *buffer, const size_t& size, const uint8_t option = _No_Return);


   uint8_t altcodeWinNum_(const uint32_t& unicode, const uint8_t option = _No_Return);

   size_t keypadBuffer_(const uint8_t* buffer, const size_t& size, const uint8_t option = _Print);


   uint8_t isNotEqual_(const char* character, const char& c, uint8_t& debut, uint8_t& fin);

   uint8_t charNum_to_keycode(const uint8_t& c);

   uint8_t altcodeOptimize_(const char* character, const uint8_t& size);


   uint8_t pressReleaseNum_(const uint8_t& n, uint8_t option);


   //    size_t printEntierPositif_(const uint32_t& v, uint8_t option);

   //    size_t printEntierNegatif_(const int32_t& v, uint8_t option);


   size_t printEntier_(uint32_t& v, uint8_t option);

   size_t printFloatDouble_(const double& d, uint8_t option);

   size_t printHex_(uint32_t val, uint8_t size);



 public:

   Keyboard_(void);

   void begin(Adafruit_USBD_HID &usb, uint8_t ID_KEYBOARD);

   void end(void);

   void releaseAll(void);


   size_t setOS(_OS myOS = None);


   void setReturn(uint8_t nb) {

     while (nb--) {

       write(TINY_KEY_RETURN);

     }

   }


   void setTab(uint8_t nb) {

     while (nb--) {

       write(TINY_KEY_TAB);

     }

   }


   void setBackspace(uint8_t nb) {

     while (nb--) {

       write(TINY_KEY_BACKSPACE);

     }

   }

   

   size_t setPrefixHex(const char* prefix = NULL);


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

   template <typename T>

   size_t printHex(T val) {

     if (val < 0 || sizeof(val) > 4) {

       return 0;

     }

     return printHex_(val, sizeof(val));

   }


   template <typename T>

   size_t printHexln(T val) {

     if (printHex(val)) {

       return (write(TINY_KEY_RETURN));

     }

     return 0;

   }

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


   size_t setDelay(const uint8_t& tempo);


   const char* getCharacter(void);

   size_t isLayout(void);

   size_t isSimpleKey(void);

   size_t isComposeKey(void);

   size_t isDeadKey(void);

   size_t isAltCode(void);

   size_t isAsciiEx(void);

   size_t asciiEx(void);

   size_t nbByte(void);

   size_t scancode(void);


   size_t getKeyEx(uint8_t asciiEx);



   size_t setAlign(const char* str, size_t& i);

   size_t setAlign(const String & s, size_t& i);


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

   template <typename T>

   size_t print(const T& v)

   {

     uint32_t valeur;


     if (v < -2147483648L || v > 4294967295UL) {

       return 0;

     }

     if (v < 0) {

       valeur = -v;

       return printEntier_(valeur , _For_Print | _Negatif);

     }

     valeur = v;

     return printEntier_(valeur , _For_Print);

   }


   template <typename T>

   size_t println(const T& v)

   {

     if (print(v)) {

       return (write(TINY_KEY_RETURN));

     }

     return 0;

   }

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


   size_t print(const __FlashStringHelper * ifsh);

   size_t println(const __FlashStringHelper * ifsh);

   size_t print(const char* str);

   size_t println(const char* str);

   size_t print(char* str) {

     return print((const char*) str);

   }

   size_t println(char* str) {

     return println((const char*) str);

   }

   size_t print(const String & s);

   size_t println(const String & s);

   size_t print(const char& c);

   size_t println(const char& c);

   size_t println(void);


   size_t print(const float & f);

   size_t println(const float & f);

   size_t print(const double & d);

   size_t println(const double & d);


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

   template <typename T>

   size_t press(const T& v)

   {

     if (v < 0 || (v > 9 && v != 13)) {

       return 0;

     }

     return pressReleaseNum_((const uint8_t)v, _Press | _For_Print);

   }


   template <typename T>

   size_t release(const T& v)

   {

     if (v < 0 || (v > 9 && v != 13)) {

       return 0;

     }

     return pressReleaseNum_((const uint8_t)v, _Release | _For_Print);

   }

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


   size_t press(const char& c);

   size_t release(const char& c);

   size_t press(const char* str);

   size_t release(const char* str);

   size_t press(char* str) {

     return press((const char*)str);

   }

   size_t release(char* str) {

     return release((const char*)str);

   }

   size_t press(const String & s);

   size_t release(const String & s);


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

   template <typename T>

   size_t printAsciiEx(const T& v)

   {

     uint32_t valeur;


     if (v < -2147483648L || v > 4294967295UL) {

       return 0;

     }

     if (v < 0) {

       valeur = -v;

       return printEntier_(valeur , _For_Print | _Negatif);

     }

     valeur = v;

     return printEntier_(valeur , _For_Print);

   }


   template <typename T>

   size_t printAsciiExln(const T& v)

   {

     if (printAsciiEx(v)) {

       return (write(TINY_KEY_RETURN));

     }

     return 0;

   }

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


   size_t printAsciiEx(const __FlashStringHelper * ifsh);

   size_t printAsciiExln(const __FlashStringHelper * ifsh);

   size_t printAsciiEx(const char* str);

   size_t printAsciiExln(const char* str);

   size_t printAsciiEx(char* str) {

     return printAsciiEx((const char*) str);

   }

   size_t printAsciiExln(char* str) {

     return printAsciiExln((const char*) str);

   }

   size_t printAsciiEx(const String & s);

   size_t printAsciiExln(const String & s);

   size_t printAsciiEx(const char& c);

   size_t printAsciiExln(const char& c);

   size_t printAsciiExln(void);


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

   template <typename T>

   size_t pressAsciiEx(const T & v)

   {

     if (v < 0 || (v > 9 && v != 13)) {

       return 0;

     }

     return pressReleaseNum_((const uint8_t)v, _Press | _For_Print);

   }


   template <typename T>

   size_t releaseAsciiEx(T & v)

   {

     if (v < 0 || (v > 9 && v != 13)) {

       return 0;

     }

     return pressReleaseNum_((const uint8_t)v, _Release | _For_Print);

   }

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


   size_t pressAsciiEx(const char& c);

   size_t releaseAsciiEx(const char& c);



   size_t write(Keycode k);

   size_t press(Keycode k);

   size_t release(Keycode k);


   size_t pressScancode(const uint16_t& scancode);

   size_t releaseScancode(const uint16_t& scancode);

   size_t printScancode(const uint16_t& scancode);

   size_t printScancodeln(const uint16_t& scancode);

   size_t printScancodeln(void);


   size_t keyCombi(Keycode key1); // peut être utile dans certain cas

   size_t keyCombi(Keycode key1, Keycode key2);

   size_t keyCombi(Keycode key1, Keycode key2, Keycode key3);

   size_t keyCombi(Keycode key1, Keycode key2, Keycode key3, Keycode key4);

   size_t keyCombi(Keycode key1, const char c);

   size_t keyCombi(Keycode key1, const char* str);

   size_t keyCombi(Keycode key1, const String & s);

   size_t keyCombi(Keycode key1, Keycode key2, const char c);

   size_t keyCombi(Keycode key1, Keycode key2, const char* str);

   size_t keyCombi(Keycode key1, Keycode key2, const String & s);

   size_t keyCombi(Keycode key1, Keycode key2, Keycode key3, const char c);

   size_t keyCombi(Keycode key1, Keycode key2, Keycode key3, const char* str);

   size_t keyCombi(Keycode key1, Keycode key2, Keycode key3, const String & s);


   size_t setPrecision(const uint8_t NB_decimale = _nbdecimale);

   size_t setNotation(const char Notation_decimale = '\0');

   size_t setSignPositif(const char signPositif = '\0');


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

   template <typename T>

   size_t altcodeWin(const T & unicode)

   {

     return altcodeWinNum_(unicode);

   }


   template <typename T>

   size_t altcodeWinln(const T & unicode)

   {

     return altcodeWinNum_(unicode, _Return);

   }

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


   size_t altcodeWin(const __FlashStringHelper * ifsh);

   size_t altcodeWinln(const __FlashStringHelper * ifsh);

   size_t altcodeWinln(const char* str);

   size_t altcodeWin(const char* str);

   size_t altcodeWinln(char* str) {

     return altcodeWinln((const char*) str);

   }

   size_t altcodeWin(char* str) {

     return altcodeWinln((const char*) str);

   }

   size_t altcodeWin(const String & s);

   size_t altcodeWinln(const String & s);

   size_t altcodeWinln(void);


   size_t altcodeWinEx(const __FlashStringHelper * ifsh);

   size_t altcodeWinExln(const __FlashStringHelper * ifsh);

   size_t altcodeWinEx(const char* str);

   size_t altcodeWinExln(const char* str);

   size_t altcodeWinEx(char* str) {

     return altcodeWinEx((const char*) str);

   }

   size_t altcodeWinExln(char* str) {

     return altcodeWinExln((const char*) str);

   }

   size_t altcodeWinEx(const String & s);

   size_t altcodeWinExln(const String & s);

   size_t altcodeWinEx(const uint8_t& asciiEx);

   size_t altcodeWinExln(const uint8_t& asciiEx);

   size_t altcodeWinExln(void);


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

   template <typename T>

   size_t printKeypad(const T & v)

   {

     uint32_t valeur;


     if (v < -2147483648L || v > 4294967295UL) {

       return 0;

     }

     if (v < 0) {

       valeur = - v;

       return printEntier_(valeur, _For_keypad | _Negatif);

     }

     valeur = v;

     return printEntier_(valeur, _For_keypad);

   }


   template <typename T>

   size_t printKeypadln(const T & v)

   {

     if (printKeypad(v)) {

       return (write(TINY_KEY_RETURN));

     }

     return 0;

   }

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


   size_t printKeypad(const char* str);

   size_t printKeypadln(const char* str);

   size_t printKeypad(const String & s);

   size_t printKeypadln(const String & s);

   size_t printKeypad(const char& c);

   size_t printKeypadln(const char& c);

   size_t printKeypadln(void);


   size_t printKeypad(const float & f);

   size_t printKeypadln(const float & f);

   size_t printKeypad(const double & d);

   size_t printKeypadln(const double & d);


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

   template <typename T>

   size_t pressKeypad(const T & v)

   {

     if (v < 0 || (v > 9 && v != 13)) {

       return 0;

     }

     return pressReleaseNum_((const uint8_t&)v, _Press | _For_keypad);

   }


   template <typename T>

   size_t releaseKeypad(const T & v)

   {

     if (v < 0 || (v > 9 && v != 13)) {

       return 0;

     }

     return pressReleaseNum_((const uint8_t&)v, _Release | _For_keypad);

   }

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


   size_t pressKeypad(const char& c);

   size_t releaseKeypad(const char& c);


};


extern Keyboard_ KeyboardEx;


#endif