c++arduinokeyboardavr
Arduino AVR C++: Simple USB HID multimedia keyboard based upon standard keyboard class
What I want to do
I have purchased a DigiSpark Pro Micro that identifies itself as Arduino Leonardo. The same chipset but much smaller. The reason I wanted this is the extra integrated USB functionality to create a multi-purpose control pad with 20 keys (design below):
Everything is working except one thing, no multimedia keys. It takes me hours to figure out what is actually wrong. I didn't find any answer on the Internet and many want to do the same like I want to do: Use multimedia keys on this device.
I figured out it is a library problem and some suggest to change/hack that standard library with useful stuff and unuseful stuff. I don't want this.
There are some other libraries, but with huge amount of stuff I don't use. I want to keep it simple and small as is possible. Just a multimedia keyboard; that's it.
Software problem
The problem seems to be a software problem. The default keyboard software does not describe itself as a multimedia keyboard, just as a regular keyboard. The hidReportDescriptor is not complete to act as a multimedia keyboard.
So I copied and renamed the library to mmkeyboard and use this in the project. This is the code I changed so far:
mmkeyboard.h
/*
TMMKeyboard.h
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 KEYBOARD_h
#define KEYBOARD_h
#include "HID.h"
#if !defined(_USING_HID)
#warning "Using legacy HID core (non pluggable)"
#else
//================================================================================
//================================================================================
// TMMKeyboard
#define KEY_LEFT_CTRL 0x80
#define KEY_LEFT_SHIFT 0x81
#define KEY_LEFT_ALT 0x82
#define KEY_LEFT_GUI 0x83
#define KEY_RIGHT_CTRL 0x84
#define KEY_RIGHT_SHIFT 0x85
#define KEY_RIGHT_ALT 0x86
#define KEY_RIGHT_GUI 0x87
#define KEY_UP_ARROW 0xDA
#define KEY_DOWN_ARROW 0xD9
#define KEY_LEFT_ARROW 0xD8
#define KEY_RIGHT_ARROW 0xD7
#define KEY_BACKSPACE 0xB2
#define KEY_TAB 0xB3
#define KEY_RETURN 0xB0
#define KEY_ESC 0xB1
#define KEY_INSERT 0xD1
#define KEY_DELETE 0xD4
#define KEY_PAGE_UP 0xD3
#define KEY_PAGE_DOWN 0xD6
#define KEY_HOME 0xD2
#define KEY_END 0xD5
#define KEY_CAPS_LOCK 0xC1
#define KEY_F1 0xC2
#define KEY_F2 0xC3
#define KEY_F3 0xC4
#define KEY_F4 0xC5
#define KEY_F5 0xC6
#define KEY_F6 0xC7
#define KEY_F7 0xC8
#define KEY_F8 0xC9
#define KEY_F9 0xCA
#define KEY_F10 0xCB
#define KEY_F11 0xCC
#define KEY_F12 0xCD
// Low level key report: up to six keys and Shift, Ctrl, etc, at once
typedef struct
{
uint8_t modifiers;
uint8_t reserved;
uint8_t keys[6];
} KeyReport;
class TMMKeyboard : public Print
{
public:
KeyReport _keyReport;
void sendReport(KeyReport* keys);
TMMKeyboard(void);
void begin(void);
void end(void);
void multimediaKey(uint8_t key);
size_t write(uint8_t k);
size_t press(uint8_t k);
size_t release(uint8_t k);
void releaseAll(void);
};
extern TMMKeyboard MMKeyboard;
#endif
#endif
mmkeyboard.cpp
/*
TMMKeyboard.cpp
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
*/
#include "mmkeyboard.h"
#if defined(_USING_HID)
//================================================================================
//================================================================================
// TMMKeyboard
static const uint8_t _hidReportDescriptor[] PROGMEM = {
0x05, 0x01, // USAGE_PAGE (Generic Desktop)
0x09, 0x06, // USAGE (Keyboard)
0xA1, 0x01, // COLLECTION (Application)
0x85, 0x02, // REPORT_ID (2)
0x75, 0x01, // REPORT_SIZE (1)
0x95, 0x08, // REPORT_COUNT (8)
0x05, 0x07, // USAGE_PAGE (Keyboard)(Key Codes)
0x19, 0xE0, // USAGE_MINIMUM (Keyboard LeftControl)(224)
0x29, 0xE7, // USAGE_MAXIMUM (Keyboard Right GUI)(231)
0x15, 0x00, // LOGICAL_MINIMUM (0)
0x25, 0x01, // LOGICAL_MAXIMUM (1)
0x81, 0x02, // INPUT (Data,Var,Abs) ; Modifier byte
0x95, 0x01, // REPORT_COUNT (1)
0x75, 0x08, // REPORT_SIZE (8)
0x81, 0x03, // INPUT (Cnst,Var,Abs) ; Reserved byte
0x95, 0x05, // REPORT_COUNT (5)
0x75, 0x01, // REPORT_SIZE (1)
0x05, 0x08, // USAGE_PAGE (LEDs)
0x19, 0x01, // USAGE_MINIMUM (Num Lock)
0x29, 0x05, // USAGE_MAXIMUM (Kana)
0x91, 0x02, // OUTPUT (Data,Var,Abs) ; LED report
0x95, 0x01, // REPORT_COUNT (1)
0x75, 0x03, // REPORT_SIZE (3)
0x91, 0x03, // OUTPUT (Cnst,Var,Abs) ; LED report padding
0x95, 0x05, // REPORT_COUNT (5)
0x75, 0x08, // REPORT_SIZE (8)
0x15, 0x00, // LOGICAL_MINIMUM (0)
0x26, 0xA4, 0x00, // LOGICAL_MAXIMUM (164)
0x05, 0x07, // USAGE_PAGE (Keyboard)(Key Codes)
0x19, 0x00, // USAGE_MINIMUM (Reserved (no event indicated))(0)
0x2A, 0xA4, 0x00, // USAGE_MAXIMUM (Keyboard Application)(164)
0x81, 0x00, // INPUT (Data,Ary,Abs)
0xC0, // END_COLLECTION
// this second multimedia key report is what handles the multimedia keys
0x05, 0x0C, // USAGE_PAGE (Consumer Devices)
0x09, 0x01, // USAGE (Consumer Control)
0xA1, 0x01, // COLLECTION (Application)
0x85, 0x03, // REPORT_ID (3)
0x19, 0x00, // USAGE_MINIMUM (Unassigned)
0x2A, 0x3C, 0x02, // USAGE_MAXIMUM
0x15, 0x00, // LOGICAL_MINIMUM (0)
0x26, 0x3C, 0x02, // LOGICAL_MAXIMUM
0x95, 0x01, // REPORT_COUNT (1)
0x75, 0x10, // REPORT_SIZE (16)
0x81, 0x00, // INPUT (Data,Ary,Abs)
0xC0 // END_COLLECTION};
};
TMMKeyboard::TMMKeyboard(void)
{
static HIDSubDescriptor node(_hidReportDescriptor, sizeof(_hidReportDescriptor));
HID().AppendDescriptor(&node);
}
void TMMKeyboard::begin(void)
{
}
void TMMKeyboard::end(void)
{
}
void TMMKeyboard::sendReport(KeyReport* keys)
{
HID().SendReport(2,keys,sizeof(KeyReport));
}
extern
const uint8_t _asciimap[128] PROGMEM;
#define SHIFT 0x80
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
};
uint8_t USBPutChar(uint8_t c);
void TMMKeyboard::multimediaKey(uint8_t key)
{
//_keyReport.keys[0] = 0x03;
//_keyReport.keys[1] = key;
_keyReport.keys[0] = key;
_keyReport.keys[1] = 0;
_keyReport.keys[2] = 0;
_keyReport.keys[3] = 0;
_keyReport.keys[4] = 0;
_keyReport.keys[5] = 0;
_keyReport.modifiers = 0;
sendReport(&_keyReport);
// Immediate release
_keyReport.keys[0] = 0;
_keyReport.keys[1] = 0;
sendReport(&_keyReport);
/*
u8 m[3];
m[0] = 0x03; // REPORT_ID MMKEY;
m[1] = key;
m[3] = 0;
// Immediate release
USB_Send(4, m, 2);
m[0] = 0x03; // REPORT_ID MMKEY;
m[1] = key;
m[3] = 0;
report_buffer[0] = 0x03;
report_buffer[1] = key;
report_buffer[2] = 0;
usbReportSend(REPSIZE_MMKEY);
// immediate release
report_buffer[0] = 0x03;
report_buffer[1] = 0;
report_buffer[2] = 0;
usbReportSend(REPSIZE_MMKEY);
*/
}
// press() adds the specified key (printing, non-printing, or modifier)
// to the persistent key report and sends the report. Because of the way
// USB HID works, the host acts like the key remains pressed until we
// call release(), releaseAll(), or otherwise clear the report and resend.
size_t TMMKeyboard::press(uint8_t k)
{
uint8_t i;
if (k >= 136) { // It's a non-printing key (not a modifier)
k = k - 136;
} else if (k >= 128) { // It's a modifier key
_keyReport.modifiers |= (1<<(k-128));
k = 0;
} else { // It's a printing key
k = pgm_read_byte(_asciimap + k);
if (!k) {
setWriteError();
return 0;
}
if (k & 0x80) { // It's a capital letter or other character reached with shift
_keyReport.modifiers |= 0x02; // The left shift modifier
k &= 0x7F;
}
}
// Add k to the key report only if it's not already present
// and if there is an empty slot.
if (_keyReport.keys[0] != k && _keyReport.keys[1] != k &&
_keyReport.keys[2] != k && _keyReport.keys[3] != k &&
_keyReport.keys[4] != k && _keyReport.keys[5] != k) {
for (i=0; i<6; i++) {
if (_keyReport.keys[i] == 0x00) {
_keyReport.keys[i] = k;
break;
}
}
if (i == 6) {
setWriteError();
return 0;
}
}
sendReport(&_keyReport);
return 1;
}
// release() takes the specified key out of the persistent key report and
// sends the report. This tells the OS the key is no longer pressed and that
// it shouldn't be repeated any more.
size_t TMMKeyboard::release(uint8_t k)
{
uint8_t i;
if (k >= 136) { // It's a non-printing key (not a modifier)
k = k - 136;
} else if (k >= 128) { // It's a modifier key
_keyReport.modifiers &= ~(1<<(k-128));
k = 0;
} else { // It's a printing key
k = pgm_read_byte(_asciimap + k);
if (!k) {
return 0;
}
if (k & 0x80) { // It's a capital letter or other character reached with shift
_keyReport.modifiers &= ~(0x02); // The left shift modifier
k &= 0x7F;
}
}
// Test the key report to see if k is present. Clear it if it exists.
// Check all positions in case the key is present more than once (which it shouldn't be)
for (i=0; i<6; i++) {
if (0 != k && _keyReport.keys[i] == k) {
_keyReport.keys[i] = 0x00;
}
}
sendReport(&_keyReport);
return 1;
}
void TMMKeyboard::releaseAll(void)
{
_keyReport.keys[0] = 0;
_keyReport.keys[1] = 0;
_keyReport.keys[2] = 0;
_keyReport.keys[3] = 0;
_keyReport.keys[4] = 0;
_keyReport.keys[5] = 0;
_keyReport.modifiers = 0;
sendReport(&_keyReport);
}
size_t TMMKeyboard::write(uint8_t c)
{
uint8_t p = press(c); // Keydown
release(c); // Keyup
return p; // Just return the result of press() since release() almost always returns 1
}
TMMKeyboard MMKeyboard;
#endif
The software question
The idea was to add an extra function for the multimedia keys only and leave the rest of the code as-is. I changed the hidReportDescriptor and this seems to work, however, I cannot figure out how to send raw/unfiltered bytes, to send media keys. See also this function:
void TMMKeyboard::multimediaKey(uint8_t key)
{
_keyReport.keys[0] = key;
_keyReport.keys[1] = 0;
_keyReport.keys[2] = 0;
_keyReport.keys[3] = 0;
_keyReport.keys[4] = 0;
_keyReport.keys[5] = 0;
_keyReport.modifiers = 0;
sendReport(&_keyReport);
// Immediate release
_keyReport.keys[0] = 0;
_keyReport.keys[1] = 0;
sendReport(&_keyReport);
}
But it doesn't work. Itried everything, and there is much different code for keys around the Internet, and I don't know what to use. It is very confusing.
How can I get this to work?
Solution
This is not a real answer, but okay. It is a kind of stupid that the default library does not support multimedia keys.
I have started to use this library instead of a changed copy of the default library:
HID Project https://github.com/NicoHood/HID
This library can be used only with the Arduino Leonardo based boards, the boards with a ATMega328U4 microcontroller.
For example:
#include <HID-Project.h>
Consumer.begin();
Consumer.write(MEDIA_VOL_UP);
This does the trick (and more). See also the documentation of this library.
- Function Prototypes with multi-dimensional arrays as a parameter
- Cancellation points in signal handlers?
- how to compiler compile if statement
- C Program Runs Surprisingly Slow
- Need assistance understanding C code about newlines
- in structure how values get stored?
- Why do I have to specify data type each time in C to printf() and scanf()?
- Defining a bit, but without a name?
- Are pass-by-value structs pushed onto the stack?
- how shared libraries reduces the space used by process ( data, code, etc)?
- Select all c file in a directory on a Makefile
- storage of bool in c under various compilers and optimization levels
- Compiler optimizations, divide macro expansions
- #line keyword in C
- #include and what actually compiles
- How to implement strstr() without casting away const?
- What is the difference between sprintf_s and snprintf?
- Size of ints and longs?
- const usage with pointers in C
- gcc compiler in cygwin does not execute properly (gives up?)
- Coderunner is not working
- How do called functions return to their caller, after being called?
- Is it possible to keep an entire array in cpu register
- What's the reason of GCC warnings for converting an string constant to 'TCHAR *'?
- How do I print in double precision?
- Nic Buffer In Raw Socket
- How to translate a GTK+ app?
- OpenCV (JavaCV) vs OpenCV (C/C++ interfaces)
- Measuring time takes some time, how to know which "point of time" is being measured?
- Autovideosink only shows the first frame