Custom Macro Control Pad

#include <Arduino.h>
#include <USB.h>
#include <USBHIDKeyboard.h>
#include <USBHIDMouse.h>
#include <USBHIDConsumerControl.h>
#include <Adafruit_NeoPixel.h>

// Edit these six actions to suit your software. The board appears as a USB HID device.

// Hoisted type definitions
enum EncoderMode : uint8_t { ZOOM_MODE, VOLUME_MODE, PAN_MODE };


// Forward declarations
void updateLighting();
void sendMacro(uint8_t keyIndex);
void handleEncoderStep(int8_t direction);
void pollKeys();
void pollEncoderButton();
void pollEncoder();

constexpr uint8_t KEY_PINS[] = {1, 2, 3, 4, 5, 6};
constexpr uint8_t KEY_COUNT = sizeof(KEY_PINS) / sizeof(KEY_PINS[0]);
constexpr uint8_t ENC_CLK_PIN = 7;
constexpr uint8_t ENC_DT_PIN = 8;
constexpr uint8_t ENC_SW_PIN = 9;
constexpr uint8_t LED_DATA_PIN = 10;
constexpr uint8_t LED_COUNT = 6;
constexpr uint8_t LED_BRIGHTNESS = 32;  // About 13% maximum; USB-friendly.
constexpr uint16_t DEBOUNCE_MS = 20;

USBHIDKeyboard Keyboard;
USBHIDMouse Mouse;
USBHIDConsumerControl ConsumerControl;
Adafruit_NeoPixel pixels(LED_COUNT, LED_DATA_PIN, NEO_GRB + NEO_KHZ800);


EncoderMode encoderMode = ZOOM_MODE;

bool keyStable[KEY_COUNT];
bool keyLastRaw[KEY_COUNT];
uint32_t keyChangedAt[KEY_COUNT];
bool encoderButtonStable;
bool encoderButtonLastRaw;
uint32_t encoderButtonChangedAt = 0;
uint8_t lastEncoderCLK;

const uint32_t modeColors[] = {
  Adafruit_NeoPixel::Color(0, 40, 100), // blue: zoom
  Adafruit_NeoPixel::Color(0, 100, 20), // green: volume
  Adafruit_NeoPixel::Color(100, 35, 0)  // orange: pan
};

void updateLighting() {
  for (uint8_t i = 0; i < LED_COUNT; ++i) {
    pixels.setPixelColor(i, modeColors[encoderMode]);
  }
  // A brighter LED marks the current mode: key 1 zoom, key 2 volume, key 3 pan.
  pixels.setPixelColor(static_cast<uint8_t>(encoderMode),
                       Adafruit_NeoPixel::Color(120, 120, 120));
  pixels.show();
}

void sendMacro(uint8_t keyIndex) {
  // Default macros: Ctrl+C, Ctrl+V, Ctrl+Z, Ctrl+Shift+Z, Ctrl+S, Ctrl+F.
  // Change this function to program the six keys for your own applications.
  switch (keyIndex) {
    case 0:
      Keyboard.press(KEY_LEFT_CTRL); Keyboard.write('c'); Keyboard.releaseAll(); break;
    case 1:
      Keyboard.press(KEY_LEFT_CTRL); Keyboard.write('v'); Keyboard.releaseAll(); break;
    case 2:
      Keyboard.press(KEY_LEFT_CTRL); Keyboard.write('z'); Keyboard.releaseAll(); break;
    case 3:
      Keyboard.press(KEY_LEFT_CTRL); Keyboard.press(KEY_LEFT_SHIFT); Keyboard.write('z'); Keyboard.releaseAll(); break;
    case 4:
      Keyboard.press(KEY_LEFT_CTRL); Keyboard.write('s'); Keyboard.releaseAll(); break;
    case 5:
      Keyboard.press(KEY_LEFT_CTRL); Keyboard.write('f'); Keyboard.releaseAll(); break;
  }
}

void handleEncoderStep(int8_t direction) {
  if (encoderMode == ZOOM_MODE) {
    // Ctrl + mouse wheel is zoom in most desktop applications and browsers.
    Keyboard.press(KEY_LEFT_CTRL);
    Mouse.move(0, 0, direction);
    Keyboard.releaseAll();
  } else if (encoderMode == VOLUME_MODE) {
    ConsumerControl.write(direction > 0 ? CONSUMER_CONTROL_VOLUME_INCREMENT
                                        : CONSUMER_CONTROL_VOLUME_DECREMENT);
  } else {
    // Horizontal scroll / pan. Application support varies.
    Mouse.move(0, 0, 0, direction);
  }
}

void pollKeys() {
  const uint32_t now = millis();
  for (uint8_t i = 0; i < KEY_COUNT; ++i) {
    const bool raw = digitalRead(KEY_PINS[i]);
    if (raw != keyLastRaw[i]) {
      keyLastRaw[i] = raw;
      keyChangedAt[i] = now;
    }
    if ((now - keyChangedAt[i] >= DEBOUNCE_MS) && raw != keyStable[i]) {
      keyStable[i] = raw;
      if (keyStable[i] == LOW) sendMacro(i);
    }
  }
}

void pollEncoderButton() {
  const uint32_t now = millis();
  const bool raw = digitalRead(ENC_SW_PIN);
  if (raw != encoderButtonLastRaw) {
    encoderButtonLastRaw = raw;
    encoderButtonChangedAt = now;
  }
  if ((now - encoderButtonChangedAt >= DEBOUNCE_MS) && raw != encoderButtonStable) {
    encoderButtonStable = raw;
    if (encoderButtonStable == LOW) {
      encoderMode = static_cast<EncoderMode>((encoderMode + 1) % 3);
      updateLighting();
    }
  }
}

void pollEncoder() {
  const uint8_t clk = digitalRead(ENC_CLK_PIN);
  if (clk != lastEncoderCLK && clk == HIGH) {
    const int8_t direction = (digitalRead(ENC_DT_PIN) != clk) ? 1 : -1;
    handleEncoderStep(direction);
  }
  lastEncoderCLK = clk;
}

void setup() {
  for (uint8_t i = 0; i < KEY_COUNT; ++i) {
    pinMode(KEY_PINS[i], INPUT_PULLUP);
    keyStable[i] = keyLastRaw[i] = digitalRead(KEY_PINS[i]);
    keyChangedAt[i] = millis();
  }
  pinMode(ENC_CLK_PIN, INPUT_PULLUP);
  pinMode(ENC_DT_PIN, INPUT_PULLUP);
  pinMode(ENC_SW_PIN, INPUT_PULLUP);
  lastEncoderCLK = digitalRead(ENC_CLK_PIN);
  encoderButtonStable = encoderButtonLastRaw = digitalRead(ENC_SW_PIN);

  pixels.begin();
  pixels.setBrightness(LED_BRIGHTNESS);
  updateLighting();

  Keyboard.begin();
  Mouse.begin();
  ConsumerControl.begin();
  USB.begin();
}

void loop() {
  pollKeys();
  pollEncoderButton();
  pollEncoder();
}