MIDI Drum Kit em Python e Arduino: 5 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Sempre quis comprar uma bateria desde que era criança. Naquela época, todo o equipamento musical não tinha todos os aplicativos digitais como temos hoje em dia, por isso os preços junto com as expectativas eram muito altos. Recentemente, decidi comprar um kit de bateria mais barato no eBay, com a única prioridade: capacidade de derrubá-lo e conectar meu próprio hardware e software ao dispositivo.

A compra não foi decepcionante em tudo: kit de bateria portátil roll-up com 9 almofadas de som diferentes, dois pedais de pedal para bumbo e chimbal e tomada de alimentação micro-USB. O que foi realmente desmotivador, foram os sons de saída (o uso real desse kit é conectar alto-falante externo e curtir). Então, eu decidi convertê-lo para o meu próprio programável via USB, kit de bateria MIDI baseado em Arduino e interface de usuário baseada em Python, para uso prático e modificações fáceis como seleções de volume, nota e canal.

Recursos do dispositivo:

• Preço baixo
• Criação de kit de bateria a partir de qualquer entrada digital - até mesmo uma variedade de botões de pressão
• Suporte de comunicação e fonte de alimentação apenas via interface USB - Integração de USB para conversor UART e dispositivo Arduino
• Peças mínimas para operação adequada
• IU baseada em Python fácil de usar
• Suporte MIDI completo com velocidade ajustável, notas e pinos Arduino
• Salvar e carregar configurações personalizadas de tambor armazenadas na memória do dispositivo

Vamos prosseguir com o projeto …

Etapa 1: Teoria de Operação

Diagrama de bloco

Em primeiro lugar, vamos nos concentrar na estrutura do projeto e dividi-la em blocos separados:

Roll-Up Drum Kit

A unidade principal do projeto. Ele consiste em 9 pads de bateria separados, onde cada pad é uma matriz de botões que mudam seu estado lógico enquanto são pressionados. Por causa de sua estrutura, existe a possibilidade de construir este kit de bateria específico a partir de qualquer botão. Cada pad de bateria é conectado ao resistor pull-up na placa eletrônica principal, portanto, enquanto o pad de bateria está sendo atingido repetidamente, uma chave específica é ligada ao terra do circuito e LOW lógico está presente na linha de pad de bateria. Quando não há pressão aplicada, a chave do pad da bateria está aberta e devido ao resistor pull-up da linha de alimentação, o lógico HIGH está presente na linha do pad da bateria. Como o objetivo do projeto é criar um dispositivo MIDI digital completo, todas as partes analógicas do PCB principal podem ser desprezadas. É importante notar que o kit de bateria tem dois pedais para bumbo e chimbal, que também estão ligados aos resistores pull-up e compartilham a mesma lógica de operação de todos os pads de bateria (discutiremos isso um pouco mais tarde)

Arduino Pro-Micro

O cérebro da bateria. Seu objetivo é detectar se há um sinal saindo de um pad de bateria e fornecer saída MIDI apropriada com todos os parâmetros necessários: nota, velocidade e duração do sinal. Devido à natureza digital dos pads de bateria, eles podem ser simplesmente vinculados às entradas digitais do Arduino (10 pinos no total). Para armazenar todas as configurações desejadas e informações MIDI, vamos usar sua memória - EEPROM, portanto, toda vez que ligamos o dispositivo, as informações MIDI estão sendo carregadas da EEPROM, tornando-a reprogramável e reconfigurável. Além disso, o Arduino Pro-Micro está disponível em um pacote muito pequeno e pode ser alocado facilmente na caixa interna do kit de bateria.

FTDI USB para conversor serial

Para programar e definir as características do nosso dispositivo com a ajuda do aplicativo para PC, é necessário converter a interface USB para serial, pois o Arduino Pro-Micro não possui USB. Como a comunicação entre os dispositivos é baseada em UART, o dispositivo FTDI é utilizado neste projeto, devido à sua simplicidade de uso independente de suas propriedades adicionais.

Aplicativo para PC - Python

Quando se trata de desenvolvimento de interfaces de usuário e projetos rápidos de construir, Python é uma solução excelente. O objetivo do aplicativo de interface do usuário é tornar muito mais conveniente redefinir as propriedades MIDI para nosso kit de bateria, armazenar informações, programar o dispositivo e fazer a comunicação entre os sistemas sem a necessidade de compilar o código repetidamente. Como estamos usando uma interface serial para nos comunicarmos com o drum kit, há uma abundância de módulos gratuitos em toda a Internet, que suportam qualquer tipo de comunicação serial. Além disso, como será discutido posteriormente, a interface UART consiste em um total de três pinos: RXD, TXD e DTR. O DTR é usado para realizar a reinicialização no módulo Arduino, portanto, quando estamos interessados em executar o aplicativo MIDI ou conectar a IU ao dispositivo do programa, não há absolutamente nenhuma necessidade de reconectar o cabo USB ou qualquer outra coisa.

Etapa 2: Peças e instrumentos

Peças

• Roll-Up Drum Kit
• 2 x Pedais de Sustentação (Normalmente, incluídos no pacote DK).
• FTDI - Conversor USB para Serial
• Arduino Pro Micro
• Cabo Micro USB

Instrumentos

• Ferro de soldar / estação
• Lata de solda
• Fio de núcleo único de diâmetro fino
• Pinças
• Cortador
• Alicate
• Faca
• Chave de fenda
• Impressora 3D (opcional - para plataformas de pedal personalizadas)

Programas

• IDE Arduino
• Python 3 ou superior
• JetBrains Pycharm
• Interface MIDI sem pêlos
• loopMIDI

Etapa 3: Solda e montagem

Como existem três módulos que devem ser combinados, o processo de soldagem e montagem é curto e simples:

• Conecte o Arduino Pro-Micro com o dispositivo FTDI, certifique-se de que as conexões estejam em conformidade com o I / O definido em cada dispositivo:

  • VBUS-VBUS
  • GND-GND
  • DTR-DTR
  • RXD-TXD
  • TXD-RXD
• Remova todos os parafusos do invólucro de plástico do tambor, certifique-se de que você pode se concentrar no cabo bloco-a-placa e seus resistores pull-up

• Soldar fios finos para o módulo Arduino-FTDI que construímos anteriormente:

  • Entradas digitais: D [2:11]
  • VBUS
  • D +
  • D-
  • GND
• Insira o módulo dentro da caixa da bateria para que os fios fiquem flutuando no mesmo lado que os resistores pull-up das almofadas
• Solde todas as entradas digitais para os terminais de pad de bateria como mostrado na última figura.
• Solda o barramento micro-USB (VBUS, D +, D-, GND) para o dispositivo FTDI, certifique-se de que não haja erros ao rastrear esses fios.
• Anexe o módulo Arduino-FTDI com cola quente na caixa da bateria
• Monte o dispositivo com os parafusos apropriados

Conseguimos, o dispositivo está montado. Vamos continuar com o código …

Etapa 4: Programação A: Arduino

Vamos descrever nosso esboço passo a passo:

Em primeiro lugar, é necessário incluir duas bibliotecas necessárias para o bom funcionamento. EEPROM já está pré-instalado no Arduino IDE, mas o módulo debouncer para kick drum deve ser instalado separadamente

#include #include

Essas opções são usadas principalmente em sequências de depuração. Se você quiser experimentar a conexão dos terminais do Arduino aos pads de bateria e determinar todas as entradas digitais, essas opções devem ser definidas

/ * Opções de desenvolvedor: Descomente o modo desejado para depuração ou inicialização * /// # define LOAD_DEFAULT_VALUES // Carrega valores constantes em vez de EEPROM // # define PRINT_PADS_PIN_NUMBERS // Imprime o número do pino conectado a um pad que foi atingido pela porta serial

Os campos constantes representam todos os valores padrão, incluindo a enumeração de pad de bateria. Para executar o dispositivo pela primeira vez, é necessário saber a conexão exata dos pedais de Hi-Hat e Kick

/ * Enumeração de tipo de tambor * /

enum DRUM_POSITION {KICK = 0, SNARE, HIHAT, RIDE, CYMBAL1, CYMBAL2, TOM_HIGH, TOM_MID, TOM_LO, HIHAT_PEDAL};

/* Valores padrão */

const uint8_t DRUM_NOTES [10] = {36, 40, 42, 51, 49, 55, 47, 45, 43, 48}; const uint8_t DRUM_VELOCITIES [10] = {110, 100, 100, 110, 110, 110, 110, 110, 110, 110}; const uint8_t DRUM_PINS [10] = {8, 6, 4, 3, 11, 9, 5, 10, 2, 7};

/ * Duração do debounce do bumbo * /

const uint8_t KICK_DB_DURATION = 30;

EEPROM é usado para armazenar / carregar todos os dados provenientes do aplicativo do PC. A extensão de endereços descrita acima mostra a localização exata das informações de MIDI para cada pad de bateria

/ * Mapeamento de endereços EEPROM

Notas: | 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 |

Pinos: | 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13 | Velocidades | 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23 | * / const uint8_t NOTES_ADDR = 0x00; const uint8_t VELOCITIES_ADDR = 0x14; const uint8_t PINS_ADDR = 0x0A;

Variáveis globais são usadas para determinar o estado de cada pad e realizar a comunicação MIDI de acordo

/* Variáveis globais */

uint8_t drumNotes [10], drumVelocities [10], drumPins [10]; // Variáveis MIDI

uint8_t uartBuffer [64]; // Buffer UART para coletar e armazenar dados MIDI Debouncer kick (DRUM_PINS [KICK], KICK_DB_DURATION); // Objeto Debouncer para bumbo volátil bool previousState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Estado lógico anterior do pad de bateria volátil bool currentState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Estados lógicos atuais do drum pad

Funções EEPROM

/ * Armazenar configurações na EEPROM * /

void storeEEPROM () {

memcpy (drumNotes, uartBuffer, 10); memcpy (drumPins, uartBuffer + 10, 10); memcpy (drumVelocities, uartBuffer + 20, 10); para (uint8_t i = 0; i <10; i ++) EEPROM.write (NOTES_ADDR + i, drumNotes ); para (uint8_t i = 0; i <10; i ++) EEPROM.write (PINS_ADDR + i, drumPins ); para (uint8_t i = 0; i <10; i ++) EEPROM.write (VELOCITIES_ADDR + i, drumVelocities ); }

/ * Carregar configurações da EEPROM * /

void loadEEPROM () {para (uint8_t i = 0; i <10; i ++) drumNotes = EEPROM.read (NOTES_ADDR + i); para (uint8_t i = 0; i <10; i ++) drumPins = EEPROM.read (PINS_ADDR + i); para (uint8_t i = 0; i <10; i ++) drumVelocities = EEPROM.read (VELOCITIES_ADDR + i); }

Inicialização de variáveis e modo de programação, no caso de pedais e boot do Arduino são ativados simultaneamente

void enterProgrammingMode () {

bool confirmBreak = false; uint8_t lineCnt = 0; uint8_t charCnt = 0; char readChar = 0; while (! confirmBreak) {if (Serial.available ()) {uartBuffer [charCnt] = Serial.read (); if (charCnt> = 29) confirmBreak = true; else charCnt ++; }} Serial.println ("OK"); storeEEPROM (); }

void initValues () {

#ifdef LOAD_DEFAULT_VALUES memcpy (drumNotes, DRUM_NOTES, 10); memcpy (drumVelocities, DRUM_VELOCITIES, 10); memcpy (drumPins, DRUM_PINS, 10); #else loadEEPROM (); #fim se }

Manipuladores de comunicação MIDI com retardo de 1 ms de tempo de retenção de nota

/ * Função de tocar nota MIDI * /

void midiOut (enum DRUM_POSITION drumIn) {

if (drumIn == HIHAT) {// Se HI-HAT foi atingido, é necessário verificar se o pedal está pressionado if (! digitalRead (drumPins [HIHAT_PEDAL])) {noteOn (0x90, drumNotes [HIHAT_PEDAL], drumVelocities [HIHAT_PEDAL]); atraso (1); noteOn (0x90, drumNotes [HIHAT_PEDAL], 0); } else {noteOn (0x90, drumNotes [HIHAT], drumVelocities [HIHAT]); atraso (1); noteOn (0x90, drumNotes [HIHAT], 0); }} else {// Transmissão regular de MIDI de bateria noteOn (0x90, drumNotes [drumIn], drumVelocities [drumIn]); atraso (1); noteOn (0x90, drumNotes [drumIn], 0); }}

void noteOn (int cmd, int pitch, int velocity) {Serial.write (cmd); Serial.write (pitch); Serial.write (velocidade); }

funções setup () e loop () com loop infinito de operação de dispositivo:

void setup () {

Serial.begin (115200);

para (uint8_t i = 0; i <10; i ++) {pinMode (i + 2, INPUT); } #ifdef PRINT_PADS_PIN_NUMBERS while (true) {// Loop de depuração infinito para (uint8_t i = 0; i <10; i ++) {if (! digitalRead (i + 2)) {Serial.print ("Pin No: D"); Serial.print (i + '0'); // Converter número em caractere ASCII}}} #else initValues (); / * Modo de programação: Se dois pedais forem pressionados durante a inicialização - o modo é ativado * / if (! DigitalRead (drumPins [KICK]) &&! DigitalRead (drumPins [HIHAT_PEDAL])) enterProgrammingMode (); #fim se }

void loop () {para (uint8_t i = 1; i <9; i = i + 1) {currentState = digitalRead (drumPins ); if (! currentState && previousState ) midiOut (i); // Compare os estados e detecte a borda descendente previousState = currentState ; } kick.update (); // Kick drum usa algoritmo de debounce personalizado if (kick.edge ()) if (kick.falling ()) midiOut (KICK); }

Etapa 5: Programação B: Python e interface do usuário

A interface do usuário do Python é um pouco complicada de entender à primeira vista, portanto, tentaríamos explicar seus fundamentos, como usar, qual função cada botão tem e como programar o dispositivo Arduino corretamente.

Interface do usuário - aplicativo

A IU é uma representação gráfica para o nosso programador de kit de bateria, tornando-o realmente fácil de usar e conveniente para programar o dispositivo Arduino a qualquer momento. A IU consiste em vários módulos gráficos vinculados à operação sugerida. vamos revisá-los um por um:

1. Imagem do conjunto de tambores: a IU do Python usa coordenadas de imagem X-Y para determinar qual tipo de tambor foi selecionado. Se uma região de bateria válida foi selecionada, uma mensagem secundária de E / S é exibida, com campos de nota, velocidade e terminal Arduino para pad de bateria dedicado. Depois que esses parâmetros são verificados pelo usuário e aprovados, esses valores podem ser transmitidos diretamente para o dispositivo Arduino.
2. Imagem do controlador externo: Para poder usar o kit de bateria MIDI com o ambiente de criação de VST / Música, é necessário executar o interpretador Serial-To-MIDI. Eu usei o Hairless, que está disponível gratuitamente e pode ser executado diretamente de nossa UI, apenas pressionando sua imagem.
3. Lista de portas COM: Para se comunicar com o Arduino, é necessário especificar sua porta COM conectada. A lista está sendo atualizada pressionando o botão Atualizar.
4. Carregar / Salvar configuração: Existem valores MIDI padrão definidos no código, que podem ser modificados pelo usuário por meio da interação com a IU. A configuração é definida no arquivo config.txt em um formato específico, que pode ser salvo ou carregado pelo usuário.
5. Botão do dispositivo de programa: Para armazenar todos os valores MIDI modificados no Arduino EEPROM, é necessário pressionar dois pedais (bumbo e pedal de chimbal) e, em seguida, aguardar a conclusão da transmissão dos dados. Se houver algum problema de comunicação, o pop-up adequado será exibido. Se a transmissão for bem-sucedida, a IU mostrará sua mensagem de sucesso.
6. Botão Sair: Basta sair do aplicativo, com a permissão do usuário.

Destaques do código Python

Há muitas coisas acontecendo no código, então iremos expandir nas funções escritas ao invés de em todo o código.

Em primeiro lugar, para usar a IU, é necessário baixar vários módulos, para fazer o código funcionar:

import osimport threading import tkinter as tk from tkinter import messagebox from tkinter import * from PIL import ImageTk, Image import numpy as np import serial import glob

Alguns dos módulos estão incluídos no pacote Python padrão. Vários módulos devem ser instalados por meio da ferramenta PIP:

pip instalar travesseiro

pip install numpy pip install ScreenInfo

É altamente recomendável executar o aplicativo via PyCharm. Em versões futuras, estou planejando exportar um executável para o projeto.

Breve explicação do código

Será muito mais fácil entender o código se olharmos para suas linhas da perspectiva das funções e classes:

1. A função principal - aqui o código começa

if _name_ == '_main_': drumkit_gui ()

2. Constantes do Drum Kit, coordenadas e informações MIDI padrão

classe Bateria: DRUM_TYPES = ["Kick", "Hihat", "Snare", "Crash 1", "Crash 2", "Tom High", "Tom Mid", "Tom Low", "Ride", "Hihat Pedal "," Controlador "]

COORDINADAS_X = [323, 117, 205, 173, 565, 271, 386, 488, 487, 135, 79]

COORDENADAS_Y = [268, 115, 192, 40, 29, 107, 104, 190, 71, 408, 208] DIMS_WIDTH = [60, 145, 130, 120, 120, 70, 70, 130, 120, 70, 145] DIMS_LENGTH = [60, 60, 80, 35, 35, 40, 40, 70, 35, 100, 50]

DRUM_ENUM = ["Kick", "Snare", "Hihat", "Ride", "Crash 1", "Crash 2", "Tom High", "Tom Mid", "Tom Low", "Hihat Pedal"]

DRUM_NOTES = [36, 40, 42, 51, 49, 55, 47, 45, 43, 48] DRUM_VELOCITIES = [110, 100, 100, 110, 110, 110, 110, 110, 110, 110, 110] DRUM_PINS = [8, 6, 4, 3, 11, 9, 5, 10, 2, 7]

3. Funções de IU - Manuseio da interface do usuário e objetos gráficos

def set_active (ui)

def secondary_ui (drum_type)

classe SelectionUi (tk. Frame)

classe Application (tk. Frame)

def drumkit_gui ()

def event_ui_clicked (evento)

def getorigin (self, event)

4. Comunicação serial

def get_serial_ports ()

def comunicar-se_com_arduino (porta)

5. Trabalhando com arquivos: Armazenar / Carregar configurações do arquivo txt

def save_config ()

def load_config ()

6. Executar o aplicativo externo hairless.exe a partir do código usando os recursos de threading do Python

classe ExternalExecutableThread (threading. Thread)

def run_hairless_executable ()

Para executar o código, existe uma lista de arquivos que devem ser anexados à pasta do projeto:

• config.txt: Arquivo de configurações
• hairless.exe: conversor de MIDI sem cabelo
• drumkit.png: Imagem que define todos os pads de percussão clicáveis em nossa IU (deve ser baixado a partir do conjunto de imagens desta etapa)
• drumgui.py: O código do projeto

É tudo o que precisamos enfatizar para que funcione. É muito importante adicionar arquivos ao projeto: imagem do conjunto de tambores, executável hairless.exe e arquivo de configurações config.txt.

E.. Aqui nós fizemos!:)

Espero que você ache este instrutível útil.

Obrigado por ler!:)