Introduction: Virtual BLE Keyboard
Demonstration
Features
Hardware Design
Schematic
Programming & Code Explained
Limitations
References
Conclusion

Published February 4, 2025 © CC BY

Toothless Bluetooth Keyboard

3 physical buttons only 50% layout Bluetooth Keyboard made with nRF 52840 MCU featuring the most essential Alpha-Numeric Keys & Special Keys

BeginnerFull instructions provided4 hours293

Things used in this project

Hardware components

Nordic Semiconductor nRF52840 Multi-Protocol SoC

Seeed Studio XIAO nRF52840 Sense (XIAO BLE Sense)

Particle Xenon

Adafruit Feather nRF52840 Express

SparkFun Cherry MX Switch Breakout

Pushbutton Switch, Momentary Spring Return

Pimoroni Maker Essentials - Switches & Potentiometers

Software apps and online services

Arduino IDE

Nordic Semiconductor nRF Connect SDK

Hand tools and fabrication machines

Soldering iron (generic)

Solder Wire, Lead Free

Story

Introduction: Virtual BLE Keyboard

This prototype project aims to create a portable, low-profile, Bluetooth-enabled (BLE) keyboard that can easily fit into your pocket. Using the nRF52840, a powerful and versatile microcontroller, this project demonstrates how to design and implement a fully functional BLE keyboard with a user-friendly OLED display. The keyboard is designed for convenience and ease of use, making it a perfect companion for mobile devices and other Bluetooth-compatible gadgets.

Demonstration

typing hackster.io

Bluetooth Pairing

Features

Here are some key features of the Low Profile Virtual BLE Pocket Keyboard:

Bluetooth Low Energy (BLE) Connectivity: Allows seamless wireless communication with compatible devices.
OLED Display: Provides a clear and concise interface for keyboard keys and status information.
Compact and Portable: The low-profile design makes it easy to carry in your pocket.
Easy Navigation: Scroll and select keys using simple button presses.
Caps Lock Functionality: Toggle between uppercase and lowercase letters.
Battery Efficient: Designed to minimize power consumption, ensuring longer battery life.
One Handed Operation: Suitable for single handed typing
Remote for Smart TVs : Can be used as a remote for Smart TVs

I have tested this keyboard on Windows and Android, not sure if it will work on iOS

Hardware Design

The hardware design of this project focuses on simplicity and portability. The key components used in this project are:

nRF52840 Microcontroller: The heart of the project, providing BLE connectivity and handling keyboard inputs.

Any development board with nRF52840 mcu can be used for this project as long as it had the Adafruit Arduino Bootloader for Feather Express is burned into it

Burning bootloader into different nRF52840 boards if needed before flashing code

OLED Display (SSD1306 128x64): Used to display the keyboard keys and other information.
Sp is Space Bar
Bk is Back Space
En is Enter
CL is Caps Lock (toggles ON/OFF)

Buttons and LEDs: Used for navigation and selection of keys, as well as indicating the connection status. I have use Cherry MX equivalent Red and Blue switches.

Here is a brief overview of the hardware connections:

The OLED display is connected to the nRF52840 using software I2C, with SCL_PIN set to 10 and SDA_PIN set to 9.
The buttons for scrolling and selecting keys are connected to pins 11, 12, and 13.
The LEDs indicating the status of the buttons are connected to analog pins A2, A3, and A4.
Additional status LEDs for Bluetooth connectivity are connected to pins 24 and 25.

Schematic

1 / 2 • Feather Express nRF52840 schematic for BLE keyboard

Programming & Code Explained

Compile and flash the attached code at the end of this page into a nRF52840 dev board from any Arduino IDE with version 1.8.7+ or later. See reference for details below.

Here is how the code works :

1. Including Libraries

#include <bluefruit.h>
#include <U8g2lib.h>

These lines include two libraries: bluefruit.h for Bluetooth functionalities and U8g2lib.h for the OLED display.

2. Defining Constants

#define SCL_PIN 10
#define SDA_PIN 9
#define KEY_BACKSPACE 0x

SCL_PIN and SDA_PIN define the pins for I2C communication.
KEY_BACKSPACE defines the keycode for the backspace key.

3. Setting Up the OLED Display

U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, SCL_PIN, SDA_PIN, U8X8_PIN_NONE);

This line sets up the OLED display using software I2C.

4. Defining Button Pins and LEDs

#define BUTTON_SELECT_PIN 11
#define BUTTON_SCROLL_UP_PIN 12
#define BUTTON_SCROLL_DOWN_PIN 3
#define LED_SELECT_PIN A7
#define LED_SCROLL_UP_PIN A2
#define LED_SCROLL_DOWN_PIN A6

These lines define the pins connected to buttons and LEDs.

5. Creating a Virtual Keyboard Layout

const char* keys[50] = {
  "q", "w", "e", "r", "t", "y", "u", "i", "o", "p",
  "a", "s", "d", "f", "g", "h", "j", "k", "l", ",",
  "z", "x", "c", "v", "b", "n", "m", ".", "@", "/",
  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", 
  "=", "!", "?", "$", "*", "&", "Sp", "Bk", "En", "CL"
};

This array represents a virtual keyboard layout with 50 keys, including letters, numbers, and special characters.

6. Setting Initial Values

int keyIndex = 0;
bool CLsLock = false;
BLEHidAdafruit blehid;
unsigned long previousMillis = 0;
const unsigned long interval = 15000;

keyIndex tracks the current key selected.
CLsLock indicates the Caps Lock status.
blehid is an instance for Bluetooth HID communication.
previousMillis and interval are used to manage display refresh timing.

7. Setup Function

void setup() {
  // Initialization code here
}

This function runs once at the beginning and sets up the OLED display, buttons, LEDs, and Bluetooth.

8. Main Loop

void loop() {
  // Main code here
}

This function runs repeatedly and handles button presses, key selection, display updates, and Bluetooth connection status.

9. Start Bluetooth Advertising

void startAdv(void) {
  // Advertising code here
}

This function sets up Bluetooth advertising to make the device discoverable.

10. Update the Display

void updateDisplay() {
  // Display update code here
}

This function updates the OLED display based on the current key selection and Caps Lock status.

11. Send Key Presses

void sendKey(const char* key) {
  // Key sending code here
}

This function sends the selected key press over Bluetooth.

12. Handle Special Keys

void sendSpecialKey(uint8_t keycode) {
  // Special key sending code here
}

This function handles sending special keys like backspace.

13. Handle Bluetooth Connection Status

void is_not_connected() {
  // Disconnected status handling code here
}

void is_connected() {
  // Connected status handling code here
}

These functions control the status LEDs based on Bluetooth connection status.

Limitations

Not suitable for gaming or programming
Not a replacement for 'real physical keyboard'
Not all modifier keys and special control keys are implemented
May exhibit input lag or debouncing

References

Adafruit Feather Express with Arduino

Flashing Bootloader into other nRF523840 board

1306 OLED display with u8g2 library

Conclusion

The Low Profile Virtual BLE Pocket Keyboard with the nRF52840 microcontroller is an excellent example of combining modern technology with experimental applications. This project not only demonstrates the capabilities of the nRF52840 but also provides a convenient and portable solution for those who need a compact and easy-to-use keyboard. Whether you're a hobbyist, a developer, or just someone looking for a cool DIY project, this BLE keyboard is sure to impress.

If you are into mechanical keyboard, this demo might be helpful to expand this into a real physical keyboard with matrix key switches layout as input, proper enclosure and your favorite key caps to add more flavor to the recipe ! By following the steps outlined in this article, you can create your own BLE keyboard and customize it to suit your needs. The flexibility of the nRF52840 and the simplicity of the design make it a perfect project for anyone interested in learning more about Bluetooth technology and embedded systems. So, grab your tools and get started on your journey to creating a low-profile virtual keyboard that fits right in your pocket!

Code

main

#include <bluefruit.h>
#include <U8g2lib.h>

// Software I2C pins
#define SCL_PIN 10
#define SDA_PIN 9

// <--aint working, direct '\u0008' will be send instead
#define KEY_BACKSPACE 0x2A 

// U8g2 OLED setup with software I2C
U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0,SCL_PIN,SDA_PIN,U8X8_PIN_NONE);


// pis allocation for feather express nRF52840
// Button definitions
#define BUTTON_SELECT_PIN  11     // red button, it presses the selected key
#define BUTTON_SCROLL_UP_PIN  12  // yellow button, moves cursor left and up
#define BUTTON_SCROLL_DOWN_PIN  13 // blue button, moves cursor right and down

// led glows when any switch press registered

#define LED_SELECT_PIN  A4
#define LED_SCROLL_UP_PIN  A3
#define LED_SCROLL_DOWN_PIN  A2

// pin allocation for particle xenon 
/*
#define BUTTON_SELECT_PIN  11
#define BUTTON_SCROLL_UP_PIN  12
#define BUTTON_SCROLL_DOWN_PIN  3

#define LED_SELECT_PIN  A7
#define LED_SCROLL_UP_PIN  A2
#define LED_SCROLL_DOWN_PIN  A6
*/

// Keyboard key array with max 10 keys per row
// this is the virtual keyboard layout
// use the buttons to select the keys and 
// send it over bluetooth
// Keyboard key array with max 10 keys per row

// press vs press and hold feature added 

const char* keys[50] = {
  "q", "w", "e", "r", "t", "y", "u", "i", "o", "p",
  "a", "s", "d", "f", "g", "h", "j", "k", "l", ",",
  "z", "x", "c", "v", "b", "n", "m", ".", "@", "/",
  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", 
  "=", "!", "?", "$", "*", "&", "Sp", "Bk", "En", "CL"
};

////////////
//// CL = CAPS LOCK

int keyIndex = 0;
bool CLsLock = false; // CLs Lock status

// Bluetooth setup
BLEHidAdafruit blehid;

// Variables for display refresh/flicker to avoid burnout
unsigned long previousMillis = 0;
const unsigned long interval = 15000;
unsigned long previousMillis2 = 0;
const unsigned long interval2 = 300;


void setup() {
  // Initialize U8g2 display
  u8g2.begin();
  u8g2.clearBuffer();

  // Button setup
  pinMode(BUTTON_SELECT_PIN, INPUT_PULLUP);
  pinMode(BUTTON_SCROLL_UP_PIN, INPUT_PULLUP);
  pinMode(BUTTON_SCROLL_DOWN_PIN, INPUT_PULLUP);
  pinMode(LED_SELECT_PIN, OUTPUT);
  pinMode(LED_SCROLL_UP_PIN, OUTPUT);
  pinMode(LED_SCROLL_DOWN_PIN, OUTPUT);

  // Bluetooth setup
  Bluefruit.begin();
  Bluefruit.setName("Bluefruit52");
  blehid.begin();
  Bluefruit.setName("Toothless Bluetooth Keyboard");
  startAdv();
  pinMode(24, OUTPUT); // blue LED
  pinMode(25, OUTPUT); // red LED
  
  // Initial display update
  updateDisplay();

  while (Bluefruit.connected() == 0) {
    is_not_connected();
  }
  digitalWrite(25, 1);
}

void loop() {
  unsigned long currentMillis = millis();

  if (digitalRead(BUTTON_SCROLL_UP_PIN) == LOW) {
    keyIndex = (keyIndex + 1) % 50;
    digitalWrite(LED_SCROLL_UP_PIN, HIGH);
    delay(30);
    updateDisplay();
    digitalWrite(LED_SCROLL_UP_PIN, LOW);
  }

  if (digitalRead(BUTTON_SCROLL_DOWN_PIN) == LOW) {
    keyIndex = (keyIndex - 1 + 50) % 50;
    digitalWrite(LED_SCROLL_DOWN_PIN, HIGH);
    delay(30);
    updateDisplay();
    digitalWrite(LED_SCROLL_DOWN_PIN, LOW);
  }

  if (digitalRead(BUTTON_SELECT_PIN) == LOW) {
    previousMillis2 = millis();
    digitalWrite(LED_SELECT_PIN, HIGH);
    if (strcmp(keys[keyIndex], "CL") == 0) { // Toggle CLs Lock
      CLsLock = !CLsLock;
      updateDisplay();
      delay(500); // Debouncing delay for CLs Lock
    } else if (strcmp(keys[keyIndex], "EN") == 0) { // Enter key
      sendKey('\n');
    } else if (strcmp(keys[keyIndex], "BK") == 0) { // Back key
      sendSpecialKey(0x2A); // HID code for backspace
    } else {
      sendKey(keys[keyIndex]);
    }
    delay(60);
    digitalWrite(LED_SELECT_PIN, LOW);
  }
//////////////////// press & hold feature /////////////////////////////////
  ////////////////////////////////////////////////////////////////////////////
  while(digitalRead(BUTTON_SELECT_PIN) == LOW && millis()<previousMillis2+interval2)
  {}
  while(digitalRead(BUTTON_SELECT_PIN) == LOW)
  {
     digitalWrite(LED_SELECT_PIN, HIGH);
    if (strcmp(keys[keyIndex], "CL") == 0) { // Toggle CLs Lock
      CLsLock = !CLsLock;
      updateDisplay();
      delay(500); // Debouncing delay for CLs Lock
    } else if (strcmp(keys[keyIndex], "EN") == 0) { // Enter key
      sendKey('\n');
    } else if (strcmp(keys[keyIndex], "BK") == 0) { // Back key
      sendSpecialKey(0x2A); // HID code for backspace
    } else {
      sendKey(keys[keyIndex]);
    }
    delay(60);
    digitalWrite(LED_SELECT_PIN, LOW);
  }

///////////////////////////////////////////////////////////////
  if (Bluefruit.connected() == 1) {
    is_connected();
  }

  if (Bluefruit.connected() == 0) {
    is_not_connected();
  }

  // Refresh display every 5 seconds
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    refreshDisplay();
  }
}

void startAdv(void) {
  // Advertising packet
  Bluefruit.Advertising.addFlags(BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);
  Bluefruit.Advertising.addTxPower();
  Bluefruit.Advertising.addAppearance(BLE_APPEARANCE_HID_KEYBOARD);
  
  // Include BLE HID service
  Bluefruit.Advertising.addService(blehid);

  // There is enough room for the dev name in the advertising packet
  Bluefruit.Advertising.addName();
  Bluefruit.Advertising.restartOnDisconnect(true);
  Bluefruit.Advertising.setInterval(40, 244);    // in unit of 0.625 ms
  Bluefruit.Advertising.setFastTimeout(30);      // number of seconds in fast mode
  Bluefruit.Advertising.start(0);                // 0 = Don't stop advertising after n seconds

  while (Bluefruit.connected() == 0) {
    is_not_connected();
  }
  digitalWrite(25, 1);
}

void updateDisplay() {
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_6x10_tr); // Small font for the keys
  const int keysPerRow = 10;
  const int keyWidth = 13;
  const int keyHeight = 10;
  const int xOffset = 1;
  const int yOffset = 3;

  for (int i = 0; i < 50; i++) {
    int x = xOffset + (i % keysPerRow) * keyWidth;
    int y = yOffset + (i / keysPerRow) * keyHeight;
    
    if (i == keyIndex) {
      u8g2.drawBox(x - 1, y - 1, keyWidth + 1, keyHeight + 1);
      u8g2.setDrawColor(0); // Invert color for selected key
    } else {
      u8g2.setDrawColor(1);
    }

    String displayString = keys[i];
    if (CLsLock && displayString.length() == 1 && displayString[0] >= 'a' && displayString[0] <= 'z') {
      displayString[0] -= 32; // Convert to uppercase correctly using ASCII
    }
    
    u8g2.setCursor(x, y + 8);
    u8g2.print(displayString);
  }

  u8g2.setDrawColor(1);
  u8g2.setFont(u8g2_font_6x10_tr); // Medium font for the CLs Lock message
  u8g2.setCursor(0, 64);
  u8g2.print(F("Caps Lock: "));
  u8g2.print(CLsLock ? "ON" : "OFF");
  u8g2.sendBuffer();
}

void refreshDisplay() {
  u8g2.setPowerSave(1); // Turn off display
  delay(100);           // Wait for 200 ms
  u8g2.setPowerSave(0); // Turn on display
  updateDisplay();      // Refresh display content
}


void sendKey(const char* key) {
  if (strcmp(key, "Bk") == 0) {
    sendSpecialKey(KEY_BACKSPACE); // Use built-in backspace constant
  } else if (strcmp(key, "En") == 0) {
    blehid.keyPress('\n');
  } else if (strcmp(key, "Sp") == 0) {
    blehid.keyPress(' ');
  } else if (strcmp(key, ",") == 0) {
    blehid.keyPress(',');
  } else if (strcmp(key, ".") == 0) {
    blehid.keyPress('.');
  } else {
    char c = key[0];
    if (CLsLock && c >= 'a' && c <= 'z') {
      c -= 32; // Convert to uppercase correctly using ASCII
    }
    blehid.keyPress(c);
  }
  blehid.keyRelease();
}

void sendSpecialKey(uint8_t keycode) {

  // sending source code style works !!
  // as hid keycode not working for some reason 
  blehid.keyPress('\u0008');
  blehid.keyRelease();
}


void sendKey(char key) {
  char keyStr[2] = {key, '\0'};
  sendKey(keyStr);
}

// Status LED functions
void is_not_connected() {
  digitalWrite(25, 0);
  delay(50);
  digitalWrite(25, 1);
  delay(50); 
}

void is_connected() {
  digitalWrite(24, 0);
  delay(25);
  digitalWrite(24, 1);
  delay(25); 
}