Your own macro keyboard: four NeoKey keys and the QT Py RP2040

2A closer look at the NeoKey

• In the middle there is a hot-swap socket soldered on the back: the switch plugs in from above and comes out again, with no solder. Without a plate to hold it, it can work loose; if needed, Adafruit suggests a dab of hot glue.
• S+ and S− are the two ends of the switch, also called A (anode) and C (cathode): there is a diode in series, so the direction matters. With the board's pull-up, S+ goes to the pin and S− to GND.
• VDD and G power the NeoPixel, from 3 to 5 V. The NeoPixel receives data on IN and passes it from OUT to the next board, as in a strip (guide no. 48).
• The two rows of pins carry the same signals, except IN (bottom) and OUT (top).

4The QT Py RP2040

We use 3V and GND for power, A0, A1, A2, A3 for the four keys and RX for the LED data. Watch the names: in the code A0–A3 are written just like that, but for the RX pin you use the GPIO number of the RP2040 chip, which is 5 (Adafruit warns that the names printed on the board are not the Arduino ones).

5Put it all on the breadboard

• The QT Py goes on the left, with the USB facing outward and its headers in rows d and h; the NeoKeys go on the right, one every nine columns, with the headers in rows c and h.
• From the top header: VDD to the + rail, G and C (that is, S−) to the − rail. From the QT Py: 3V to +, GND to −.
• The data go along a chain: RX → IN of key 1, then OUT of each key → IN of the next one. The jumper wires run down through the gap between one board and the next.
• From the bottom header, S+ of each key goes to a pin: key 1 → A3, 2 → A2, 3 → A1, 4 → A0.

6Set up the Arduino IDE

• In File → Preferences, in the Additional boards manager URLs field, paste https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json
• In the Boards Manager install Raspberry Pi Pico/RP2040/RP2350 by Earle F. Philhower, III and choose the Adafruit QT Py RP2040 board. In the Tools menu leave USB Stack set to Pico SDK: the Keyboard library only works that way.
• In the Library Manager install Adafruit NeoPixel. Keyboard, on the other hand, already comes with the board package.
• The first upload: hold down BOOT while you plug in the USB cable, choose the UF2 Board port and upload. From then on the new serial port is enough.

7Test the wiring

// Wiring test: each key has its own color and turns white when you press it.
// The Serial Monitor prints the key number. Here the board is not a keyboard yet.
#include <Adafruit_NeoPixel.h>

const int LED_PIN = 5;                     // RX pin of the QT Py: goes to IN of key 1
const int KEYS[4] = {A3, A2, A1, A0};      // S+ pins of keys 1, 2, 3 and 4
const uint32_t COLORS[4] = {0x0040FF, 0x00FF40, 0xFF8000, 0xC000FF};

Adafruit_NeoPixel leds(4, LED_PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  Serial.begin(115200);
  for (int i = 0; i < 4; i++) {
    pinMode(KEYS[i], INPUT_PULLUP);        // internal pull-up: at rest the pin reads HIGH
  }
  leds.begin();
  leds.setBrightness(30);                  // low light, from 0 to 255
}

void loop() {
  for (int i = 0; i < 4; i++) {
    bool pressed = digitalRead(KEYS[i]) == LOW;    // pressed: the pin goes to GND
    leds.setPixelColor(i, pressed ? 0xFFFFFF : COLORS[i]);
    if (pressed) {
      Serial.print("Key ");
      Serial.println(i + 1);
    }
  }
  leds.show();
  delay(100);
}

This first sketch leaves the computer's keyboard alone: it lights the LEDs and prints the key you press on the Serial Monitor (115200 baud). INPUT_PULLUP keeps the pin high until the switch pulls it to GND (guide no. 20).

8Now it becomes a keyboard

// Four-key macro keyboard: QT Py RP2040 and four Adafruit NeoKeys.
// The computer sees it as a USB keyboard and each key sends a shortcut.
#include <Adafruit_NeoPixel.h>
#include <Keyboard.h>

const int LED_PIN = 5;                     // RX pin of the QT Py: goes to IN of key 1
const int KEYS[4] = {A3, A2, A1, A0};      // S+ pins of keys 1, 2, 3 and 4
const uint32_t COLORS[4] = {0x0040FF, 0x00FF40, 0xFF8000, 0xC000FF};

Adafruit_NeoPixel leds(4, LED_PIN, NEO_GRB + NEO_KHZ800);
bool down[4];                              // is the key down?
unsigned long changed[4];                  // when it last changed (ms)

void setup() {
  for (int i = 0; i < 4; i++) {
    pinMode(KEYS[i], INPUT_PULLUP);
  }
  leds.begin();
  leds.setBrightness(30);
  Keyboard.begin(KeyboardLayout_en_US);    // the computer uses the US keyboard layout
}

// Ctrl plus a letter, as if you pressed them yourself with two fingers
void shortcut(char letter) {
  Keyboard.press(KEY_LEFT_CTRL);           // on the Mac, instead of Ctrl: KEY_LEFT_GUI
  Keyboard.press(letter);
  delay(20);
  Keyboard.releaseAll();
}

void macro(int key) {
  if (key == 0) shortcut('c');             // copy
  if (key == 1) shortcut('v');             // paste
  if (key == 2) shortcut('z');             // undo
  if (key == 3) Keyboard.print("name@example.com");   // write your email here
}

void loop() {
  for (int i = 0; i < 4; i++) {
    bool now = digitalRead(KEYS[i]) == LOW;
    if (now != down[i] && millis() - changed[i] > 30) {  // 30 ms against bounce
      down[i] = now;
      changed[i] = millis();
      if (now) macro(i);                   // only once, when you press it
    }
    leds.setPixelColor(i, down[i] ? 0xFFFFFF : COLORS[i]);
  }
  leds.show();
  delay(5);
}

• Keyboard.begin(KeyboardLayout_en_US) tells the library that the computer uses the US keyboard layout, which is also the library default: that way the characters typed with Keyboard.print, such as the @, come out right. If your computer uses another layout, write its name here: the library also has, for example, KeyboardLayout_de_DE, KeyboardLayout_fr_FR and KeyboardLayout_it_IT.
• Keyboard.press presses a key and holds it down, Keyboard.releaseAll lets them all go: Ctrl plus a letter makes the shortcut.
• The macro runs only once, when you press the key; the 30 ms wait stops the switch from bouncing.

9On the Mac and beyond

• On the Mac the same shortcuts use Cmd: instead of KEY_LEFT_CTRL write KEY_LEFT_GUI, which on Windows is the key with the logo.
• The library only sends characters from the ASCII table: no accented letters in Keyboard.print.
• Finally, put on the keycaps. If the switch comes out with the keycap when you pull it off, a dab of hot glue, as Adafruit suggests, holds it in place.