I2C Keyboard with 100mm Bi2C flex cable

Introducing the Bi2C-KBD, a game-changing I2C controlled numeric keypad that’s all set to redefine your input experience.

Designed for anyone who needs an ease to use, efficient and simple keypad for their embedded systems project. This I2C compatible keypad is a must-have addition to your Challenger setup. With its compact size and robust design, the Bi2C-KBD doesn’t just blend in; it stands out and outperforms =).

Key Features:

1. I2C Interface: The Bi2C-KBD boasts a streamlined I2C interface, providing bidirectional two-wire communication with only two data lines: SDA (data line) and SCL (clock line). It facilitates seamless connection to microcontrollers, even those with limited I/O capabilities. Communicate with multiple devices using just two wires, all while maintaining high-speed data transfer. And of course we have used the Bi2C interface connection scheme with super easy to use flex cables.

3. Energy Efficiency: The Bi2C-KBD doesn’t just talk the talk, it walks the walk. With its low power consumption, the Bi2C-KBD is perfect for battery-operated projects. It runs efficiently even on low-power devices, ensuring longer operational time.

4. Ease of Integration: The Bi2C-KBD is compatible with basically any microcontroller as long as you have a Bi2C connector and can be easily integrated into your existing projects. Its compact design and easy setup make it a perfect choice for applications where space is a premium.

5. Advanced Features: Bi2C-KBD is loaded with advanced features like built-in pull-up resistors and auto-acknowledge features, providing an effortless and seamless user experience.

In summary, the Bi2C-KBD is more than just a numeric keypad; it’s a compact, efficient, and robust solution for your input needs.

Software support

The keyboard is built around the ATtiny1616 micro controller and it comes with a preloaded open sourced firmware as well as an Arduino library that simplifies the usage to the point where you only need a couple of lines of code to start using the keyboard.

The following example starts the keyboard driver and starts receiving keys and printing them. You can do tons of more stuff like hooking it up to an interrupt and getting interrupts on receiving a key stroke and fiddling with the built in LED’s. All that is explained in the accompanying examples in the Arduino library.

#include <iLabs_Bi2C_KBD.h>

void setup() {

void loop() {
  if (bi2c_kbd.available()) {
    // Read the current character from the key board.
    uint8_t in = bi2c_kbd.read();
    Serial.printf("Key: %c\n\r", in);


Weight 0.01 kg
Dimensions 5.2 × 4.1 × 0.53 cm

We’ve created a simple to use Arduino library to be used together with this keyboard.

There are examples in the library that shows how to use it and how to access the different features. Here’s a rundown of the different methods and a short description to each.


Declaration: void begin(uint8_t address = KBD_CTRLR_ADDRESS, int intpin = -1, void (*int_cb)() = NULL)

This function is used to initialize the library and set its mode of operation.  If the interrupt pin is set to anything else than -1 an interrupt is connected to the driver and you will get a callback whenever the keyboard fires its interrupt pin.


Declaration: void reset()

Calling the reset function will reset the keyboard controller chip on the module. It takes a around 20mS for the keyboard to come back from reset and you can either wait for a specified amount, ie. delay(25), or probe the device with an I2C scanner.


Declaration: size_t available()

This function returns the number of characters that is currently in the FIFO of the keyboard controller. It returns 0 when there are no characters left.


Declaration: uint8_t read()

Returns the next character from the FIFO in the keyboard controller. To make life easy the characters are ASCII encoded and matches the characters on the printed circuit board. If you accidentally try to read the FIFO when it is empty you will receive 0xFF in return.


Declaration: void flush()

Simply flushes the FIFO in the keyboard controller in case you don’t want to handle anything that has been stored.


Declaration: void disableNumKeys(bool disable = true)

This function disables the numerical part of the keyboard and only accepts the A-D buttons. It will disable the buttons by default but by executing disableNumKeys(false) you will re-enable the numerical keys again.


Declaration: void disableAlphaKeys(bool disable = true)

This function disables the alpha numeric keys on the keyboard and only accepts the *, # and 0-9 buttons. It will disable the buttons by default but by executing disableAlphaKeys(false) you will re-enable the alpha numerical keys again.


Declaration: bool setLEDMode(uint32_t led, uint8_t mode)

This will set the operation mode of the specified LED on the board. To address a LED you should use one of the following declarations:


and use one of the following LED modes.

LED_CANDLE, // Currently only supported on B LED



Declaration: uint8_t getLEDMode(uint32_t led)

This will return the led mode associated with the given LED. This will return the mode as defined in the table above.

The keyboard controller is based on a ATtiny1616 from Microchip. The firmware is open source so that you can modify it to suit your own needs. The board comes with an exposed UPDI programmer interface that makes it super easy to start playing around with modifying the firmware.


There are no reviews yet.

Only logged in customers who have purchased this product may leave a review.

You may also like…