Build Instructions

Collapse

• 1

  Keyboard Assembly process

  • The assembly process begins with placing all 25 switches in their respective pads on the Matrix PCB; we are utilizing 6x6 Tacktile buttons here, and we must ensure that all buttons are correctly added to their pads, as some of the buttons' pins bend when placed in the footprint.
  • Next, we solder all of the switch pads on the bottom side of the board with a soldering iron.
  • Following that, we place a CON10 male header pin in its place and solder its pads from the top side of the board.

  Matrix Board is now assembled.

• 2

  WIRING

  In terms of wiring, we linked the column pins of our matrix keyboard (C1-C5) to GPIO6, GPIO7, GPIO8, GPIO9, and GPIO10. From R1 to R5, the row pins are connected via GPIO16, GPIO17, GPIO18, GPIO19, and GPIO20.

  The speaker output pin is GPIO21, which is connected to the audio amplifier's L input. The 5V pin of the audio amplifier is linked to the PICO's VBUS, while GND is connected to GND. The speaker is attached to the audio amplifier's left output.

  A simplified schematic is attached if you want to recreate the circuit.

• 3

  CODE

  Here's the code we used.

  #include <Wire.h>
  
  // Define keypad pins
  const int rows = 5;
  const int cols = 5;
  const int rowPins[rows] = {16, 17, 18, 19, 20}; // Updated row pins
  const int colPins[cols] = {6, 7, 8, 9, 10}; // Updated col pins
  
  // Define frequencies for buttons
  const int frequencies[5][3] = {
    {110, 123, 146}, // Row 1
    {164, 196, 220}, // Row 2
    {246, 294, 330}, // Row 3
    {349, 392, 440}, // Row 4
    {494, 523, 587}  // Row 5 (last button will be for record)
  };
  
  // Pin for speaker
  const int speakerPin = 21;
  
  // Recording variables
  bool isRecording = false;
  unsigned long sequence[100];
  int sequenceIndex = 0;
  
  // Button coordinates
  const int recordRow = 4;
  const int recordCol = 2; // Last button in Row 5
  const int delayRow = 4;
  const int delayCol = 1; // Second to last button in Row 5
  
  void setup() {
    Serial.begin(115200);
  
    // Initialize row pins as inputs
    for (int i = 0; i < rows; i++) {
      pinMode(rowPins[i], INPUT_PULLUP);
    }
  
    // Initialize column pins as outputs
    for (int i = 0; i < cols; i++) {
      pinMode(colPins[i], OUTPUT);
      digitalWrite(colPins[i], HIGH);
    }
  
    // Initialize speaker pin as output
    pinMode(speakerPin, OUTPUT);
    Serial.println("Setup complete.");
  }
  
  void playSound(int freq) {
    tone(speakerPin, freq, 200); // Play sound on pin 21 for 200ms
    Serial.print("Playing sound at frequency: ");
    Serial.println(freq);
  }
  
  void playSequence() {
    for (int i = 0; i < sequenceIndex; i++) {
      playSound(sequence[i]);
      if (digitalRead(rowPins[delayRow]) == LOW && digitalRead(colPins[delayCol]) == LOW) {
        delay(750); // Add delay if delay button is pressed (adjust as needed)
      } else {
        delay(250); // Default delay between notes in the sequence
      }
    }
  }
  
  void loop() {
    for (int i = 0; i < cols; i++) {
      digitalWrite(colPins[i], LOW); // Activate column i
      for (int j = 0; j < rows; j++) {
        if (digitalRead(rowPins[j]) == LOW) { // Button press detected
          if (i == recordCol && j == recordRow) { // Check if it's the record button
            if (isRecording) {
              isRecording = false;
              Serial.println("Recording stopped. Playing sequence...");
              tone(speakerPin, 880, 500); // Play tone to signal recording stop
              delay(500); // Delay to avoid multiple triggers
              playSequence(); // Play recorded sequence
            } else {
              isRecording = true;
              sequenceIndex = 0;
              Serial.println("Recording started...");
              tone(speakerPin, 440, 500); // Play tone to signal recording start
              delay(500); // Delay to avoid multiple triggers
            }
          } else if (!(i == delayCol && j == delayRow)) { // First 10 buttons for tones, excluding delay button
            playSound(frequencies[j][i]);
            if (isRecording) {
              sequence[sequenceIndex] = frequencies[j][i];
              sequenceIndex++;
              Serial.print("Recording note: ");
              Serial.println(frequencies[j][i]);
            }
          }
          delay(200); // Debounce delay
        }
      }
      digitalWrite(colPins[i], HIGH); // Deactivate column i
    }
  }

  This test sketch utilises the 5x5 matrix keyboard to generate bass tones, record sequence, and add time delay during playback.

  The code iterates through each column, setting it LOW to activate it, and then checks each row for a button press; if a button press is detected, it identifies the button based on its row and column position.

  When the record button (located at `recordRow` and `recordCol`) is pressed, it toggles recording mode; if recording mode is active, each button press stores the corresponding frequency in the sequence array, and pressing the record button again stops recording and plays back the recorded sequence.

View all 4 instructions