|
/* |
|
* Sample program for ESP32 acting as a Bluetooth keyboard |
|
* |
|
* Copyright (c) 2019 Manuel Bl |
|
* |
|
* Licensed under MIT License |
|
* https://opensource.org/licenses/MIT |
|
*/ |
|
|
|
// |
|
// This program lets an ESP32 act as a keyboard connected via Bluetooth. |
|
// When a button attached to the ESP32 is pressed, it will generate the key strokes for a message. |
|
// |
|
// For the setup, a momentary button should be connected to pin 2 and to ground. |
|
// Pin 2 will be configured as an input with pull-up. |
|
// |
|
// In order to receive the message, add the ESP32 as a Bluetooth keyboard of your computer |
|
// or mobile phone: |
|
// |
|
// 1. Go to your computers/phones settings |
|
// 2. Ensure Bluetooth is turned on |
|
// 3. Scan for Bluetooth devices |
|
// 4. Connect to the device called "ESP32 Keyboard" |
|
// 5. Open an empty document in a text editor |
|
// 6. Press the button attached to the ESP32 |
|
|
|
#define US_KEYBOARD 1 |
|
|
|
#include <Arduino.h> |
|
#include "BLEDevice.h" |
|
#include "BLEHIDDevice.h" |
|
#include "HIDTypes.h" |
|
#include "HIDKeyboardTypes.h" |
|
|
|
|
|
// Change the below values if desired |
|
#define BUTTON_PIN 2 |
|
#define MESSAGE "Hello from ESP32\n" |
|
#define DEVICE_NAME "ESP32 Keyboard" |
|
|
|
|
|
// Forward declarations |
|
void bluetoothTask(void*); |
|
void typeText(const char* text); |
|
|
|
|
|
bool isBleConnected = false; |
|
|
|
|
|
void setup() { |
|
Serial.begin(115200); |
|
|
|
// configure pin for button |
|
pinMode(BUTTON_PIN, INPUT_PULLUP); |
|
|
|
// start Bluetooth task |
|
xTaskCreate(bluetoothTask, "bluetooth", 20000, NULL, 5, NULL); |
|
} |
|
|
|
|
|
void loop() { |
|
if (isBleConnected && digitalRead(BUTTON_PIN) == LOW) { |
|
// button has been pressed: type message |
|
Serial.println(MESSAGE); |
|
typeText(MESSAGE); |
|
} |
|
|
|
delay(100); |
|
} |
|
|
|
|
|
// Message (report) sent when a key is pressed or released |
|
struct InputReport { |
|
uint8_t modifiers; // bitmask: CTRL = 1, SHIFT = 2, ALT = 4 |
|
uint8_t reserved; // must be 0 |
|
uint8_t pressedKeys[6]; // up to six concurrenlty pressed keys |
|
}; |
|
|
|
// Message (report) received when an LED's state changed |
|
struct OutputReport { |
|
uint8_t leds; // bitmask: num lock = 1, caps lock = 2, scroll lock = 4, compose = 8, kana = 16 |
|
}; |
|
|
|
|
|
// The report map describes the HID device (a keyboard in this case) and |
|
// the messages (reports in HID terms) sent and received. |
|
static const uint8_t REPORT_MAP[] = { |
|
USAGE_PAGE(1), 0x01, // Generic Desktop Controls |
|
USAGE(1), 0x06, // Keyboard |
|
COLLECTION(1), 0x01, // Application |
|
REPORT_ID(1), 0x01, // Report ID (1) |
|
USAGE_PAGE(1), 0x07, // Keyboard/Keypad |
|
USAGE_MINIMUM(1), 0xE0, // Keyboard Left Control |
|
USAGE_MAXIMUM(1), 0xE7, // Keyboard Right Control |
|
LOGICAL_MINIMUM(1), 0x00, // Each bit is either 0 or 1 |
|
LOGICAL_MAXIMUM(1), 0x01, |
|
REPORT_COUNT(1), 0x08, // 8 bits for the modifier keys |
|
REPORT_SIZE(1), 0x01, |
|
HIDINPUT(1), 0x02, // Data, Var, Abs |
|
REPORT_COUNT(1), 0x01, // 1 byte (unused) |
|
REPORT_SIZE(1), 0x08, |
|
HIDINPUT(1), 0x01, // Const, Array, Abs |
|
REPORT_COUNT(1), 0x06, // 6 bytes (for up to 6 concurrently pressed keys) |
|
REPORT_SIZE(1), 0x08, |
|
LOGICAL_MINIMUM(1), 0x00, |
|
LOGICAL_MAXIMUM(1), 0x65, // 101 keys |
|
USAGE_MINIMUM(1), 0x00, |
|
USAGE_MAXIMUM(1), 0x65, |
|
HIDINPUT(1), 0x00, // Data, Array, Abs |
|
REPORT_COUNT(1), 0x05, // 5 bits (Num lock, Caps lock, Scroll lock, Compose, Kana) |
|
REPORT_SIZE(1), 0x01, |
|
USAGE_PAGE(1), 0x08, // LEDs |
|
USAGE_MINIMUM(1), 0x01, // Num Lock |
|
USAGE_MAXIMUM(1), 0x05, // Kana |
|
LOGICAL_MINIMUM(1), 0x00, |
|
LOGICAL_MAXIMUM(1), 0x01, |
|
HIDOUTPUT(1), 0x02, // Data, Var, Abs |
|
REPORT_COUNT(1), 0x01, // 3 bits (Padding) |
|
REPORT_SIZE(1), 0x03, |
|
HIDOUTPUT(1), 0x01, // Const, Array, Abs |
|
END_COLLECTION(0) // End application collection |
|
}; |
|
|
|
|
|
BLEHIDDevice* hid; |
|
BLECharacteristic* input; |
|
BLECharacteristic* output; |
|
|
|
const InputReport NO_KEY_PRESSED = { }; |
|
|
|
|
|
/* |
|
* Callbacks related to BLE connection |
|
*/ |
|
class BleKeyboardCallbacks : public BLEServerCallbacks { |
|
|
|
void onConnect(BLEServer* server) { |
|
isBleConnected = true; |
|
|
|
// Allow notifications for characteristics |
|
BLE2902* cccDesc = (BLE2902*)input->getDescriptorByUUID(BLEUUID((uint16_t)0x2902)); |
|
cccDesc->setNotifications(true); |
|
|
|
Serial.println("Client has connected"); |
|
} |
|
|
|
void onDisconnect(BLEServer* server) { |
|
isBleConnected = false; |
|
|
|
// Disallow notifications for characteristics |
|
BLE2902* cccDesc = (BLE2902*)input->getDescriptorByUUID(BLEUUID((uint16_t)0x2902)); |
|
cccDesc->setNotifications(false); |
|
|
|
Serial.println("Client has disconnected"); |
|
} |
|
}; |
|
|
|
|
|
/* |
|
* Called when the client (computer, smart phone) wants to turn on or off |
|
* the LEDs in the keyboard. |
|
* |
|
* bit 0 - NUM LOCK |
|
* bit 1 - CAPS LOCK |
|
* bit 2 - SCROLL LOCK |
|
*/ |
|
class OutputCallbacks : public BLECharacteristicCallbacks { |
|
void onWrite(BLECharacteristic* characteristic) { |
|
OutputReport* report = (OutputReport*) characteristic->getData(); |
|
Serial.print("LED state: "); |
|
Serial.print((int) report->leds); |
|
Serial.println(); |
|
} |
|
}; |
|
|
|
|
|
void bluetoothTask(void*) { |
|
|
|
// initialize the device |
|
BLEDevice::init(DEVICE_NAME); |
|
BLEServer* server = BLEDevice::createServer(); |
|
server->setCallbacks(new BleKeyboardCallbacks()); |
|
|
|
// create an HID device |
|
hid = new BLEHIDDevice(server); |
|
input = hid->inputReport(1); // report ID |
|
output = hid->outputReport(1); // report ID |
|
output->setCallbacks(new OutputCallbacks()); |
|
|
|
// set manufacturer name |
|
hid->manufacturer()->setValue("Maker Community"); |
|
// set USB vendor and product ID |
|
hid->pnp(0x02, 0xe502, 0xa111, 0x0210); |
|
// information about HID device: device is not localized, device can be connected |
|
hid->hidInfo(0x00, 0x02); |
|
|
|
// Security: device requires bonding |
|
BLESecurity* security = new BLESecurity(); |
|
security->setAuthenticationMode(ESP_LE_AUTH_BOND); |
|
|
|
// set report map |
|
hid->reportMap((uint8_t*)REPORT_MAP, sizeof(REPORT_MAP)); |
|
hid->startServices(); |
|
|
|
// set battery level to 100% |
|
hid->setBatteryLevel(100); |
|
|
|
// advertise the services |
|
BLEAdvertising* advertising = server->getAdvertising(); |
|
advertising->setAppearance(HID_KEYBOARD); |
|
advertising->addServiceUUID(hid->hidService()->getUUID()); |
|
advertising->addServiceUUID(hid->deviceInfo()->getUUID()); |
|
advertising->addServiceUUID(hid->batteryService()->getUUID()); |
|
advertising->start(); |
|
|
|
Serial.println("BLE ready"); |
|
delay(portMAX_DELAY); |
|
}; |
|
|
|
|
|
void typeText(const char* text) { |
|
int len = strlen(text); |
|
for (int i = 0; i < len; i++) { |
|
|
|
// translate character to key combination |
|
uint8_t val = (uint8_t)text[i]; |
|
if (val > KEYMAP_SIZE) |
|
continue; // character not available on keyboard - skip |
|
KEYMAP map = keymap[val]; |
|
|
|
// create input report |
|
InputReport report = { |
|
.modifiers = map.modifier, |
|
.reserved = 0, |
|
.pressedKeys = { |
|
map.usage, |
|
0, 0, 0, 0, 0 |
|
} |
|
}; |
|
|
|
// send the input report |
|
input->setValue((uint8_t*)&report, sizeof(report)); |
|
input->notify(); |
|
|
|
delay(5); |
|
|
|
// release all keys between two characters; otherwise two identical |
|
// consecutive characters are treated as just one key press |
|
input->setValue((uint8_t*)&NO_KEY_PRESSED, sizeof(NO_KEY_PRESSED)); |
|
input->notify(); |
|
|
|
delay(5); |
|
} |
|
} |
@simplyrohan The code on this page is quite small. I doubt that any optimizations will make a relevant difference.
The major contributor to the code and RAM size is Bluetooth itself. It's a non-trivial protocol. The moment a single Bluetooth function is used, a large library is pulled in.
So if you need to shrink the code, focus on the Bluetooth library: