Build Instructions

Collapse

• 1

  PCB ASSEMBLY

  • We begin the assembly process by placing two CON18 male header pins side by side on a breadboard.
  • The PCB is then placed over the header pins, and the connections are secured by soldering the leads using a soldering iron. This is a clever and reliable method for soldering breakout boards or modules, as the breadboard helps keep the header pins perfectly straight while soldering.
  • Next, we place a CON2 connector onto the speaker pads on the breakout board.
  • After flipping the board over, we solder the connector in place.
• 2

  ENCODER WIRING

  • We connected GPIO 0 and GPIO 1 to the encoder’s A and B pins through 10 kΩ resistors placed in series.
  • The middle pin of the encoder, along with one pin of the encoder’s push button, was connected to the GND of the LattePanda.
  • The remaining encoder switch pin was connected to GPIO 3.
  • For sound output, we connected an 8-ohm, 0.5-watt round speaker to our setup using the onboard JST connector, simply plugging the speaker directly into it.
  • We used single-core jumper wires for all the connections, and once the wiring was complete, we moved on to the code uploading process.
• 3

  MAIN CODE

  • Before uploading the code, we first set up the RP2040 in the Arduino IDE. We navigated to File>Preferences and added the below JSON URL to the Additional Boards Manager URLs.

  https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json

  • Next, we opened the Boards Manager, searched for Raspberry Pi Pico, and installed the board package by Earle Philhower.
  • After installing the Raspberry Pi Pico core for the Arduino IDE, we uploaded our main code to the onboard RP2040 co-processor.
  • To put the RP2040 into boot mode, we pressed and held the BOOTSEL button, then pressed and released the RST button, and finally released the BOOTSEL button. The operating system then detected the RP2040 as a new USB Mass Storage Device.

  We uploaded the below code into our coprocessor.

  #include <Adafruit_TinyUSB.h>
  // ================== PINS ==================
  #define ENC_A   0
  #define ENC_B   1
  #define ENC_BTN 2
  // ================== HID ===================
  Adafruit_USBD_HID hid_consumer;
  Adafruit_USBD_HID hid_keyboard;
  uint8_t const consumer_desc[] = {
  TUD_HID_REPORT_DESC_CONSUMER()
  };
  uint8_t const keyboard_desc[] = {
  TUD_HID_REPORT_DESC_KEYBOARD()
  };
  // ================== MODE ==================
  bool volumeMode = true;
  bool lastBtn = HIGH;
  // ================== ENCODER (DETENT LOCK) ==================
  int8_t readEncoder() {
  static uint8_t last = 0b11;
  static int8_t count = 0;
  uint8_t now = 0;
  if (digitalRead(ENC_A)) now |= 1;
  if (digitalRead(ENC_B)) now |= 2;
  if (now != last) {
  if ((last == 0b11 && now == 0b01) ||
  (last == 0b01 && now == 0b00) ||
  (last == 0b00 && now == 0b10) ||
  (last == 0b10 && now == 0b11))
  count++;
  if ((last == 0b11 && now == 0b10) ||
  (last == 0b10 && now == 0b00) ||
  (last == 0b00 && now == 0b01) ||
  (last == 0b01 && now == 0b11))
  count--;
  last = now;
  }
  if (now == 0b11) {
  if (count >= 4) { count = 0; return +1; }
  if (count <= -4) { count = 0; return -1; }
  count = 0;
  }
  return 0;
  }
  // ================== HID SEND ==================
  void sendVolume(uint16_t key) {
  hid_consumer.sendReport(0, &key, sizeof(key));
  delay(2);
  uint16_t zero = 0;
  hid_consumer.sendReport(0, &zero, sizeof(zero));
  }
  void sendKey(uint8_t keycode) {
  uint8_t press[8] = {0};
  uint8_t release[8] = {0};
  press[2] = keycode;
  hid_keyboard.sendReport(0, press, sizeof(press));
  delay(2);
  hid_keyboard.sendReport(0, release, sizeof(release));
  }
  // ================== SETUP ==================
  void setup() {
  pinMode(ENC_A, INPUT_PULLUP);
  pinMode(ENC_B, INPUT_PULLUP);
  pinMode(ENC_BTN, INPUT_PULLUP);
  hid_consumer.setReportDescriptor(consumer_desc, sizeof(consumer_desc));
  hid_consumer.begin();
  hid_keyboard.setReportDescriptor(keyboard_desc, sizeof(keyboard_desc));
  hid_keyboard.begin();
  while (!TinyUSBDevice.mounted()) delay(10);
  }
  // ================== LOOP ==================
  void loop() {
  // Button toggle
  bool btn = digitalRead(ENC_BTN);
  if (lastBtn == HIGH && btn == LOW) {
  volumeMode = !volumeMode;
  delay(300);
  }
  lastBtn = btn;
  // Encoder
  int8_t move = readEncoder();
  if (move != 0) {
  if (volumeMode) {
  if (move > 0)
  sendVolume(HID_USAGE_CONSUMER_VOLUME_INCREMENT);
  else
  sendVolume(HID_USAGE_CONSUMER_VOLUME_DECREMENT);
  } else {
  if (move > 0)
  sendKey(HID_KEY_PAGE_DOWN);
  else
  sendKey(HID_KEY_PAGE_UP);
  }
  }
  }

  Before using this sketch, we installed adafruit TinyUSB library before uploading, after uploading our RP2040 coprocessor turns into a USB HID device that can function as both a media controller and a keyboard input.

  The rotary encoder is read using a detent-locked quadrature decoding method, ensuring that each physical click of the encoder results in only one action. By default, the encoder controls system volume, and pressing the encoder button toggles the mode between volume control and page scrolling.

  In volume mode, rotating the encoder sends USB consumer control commands to increase or decrease the system volume, while in scroll mode, it sends keyboard Page Up and Page Down key events.

View all 9 instructions