Kit de bateria MIDI a Python i Arduino: 5 passos (amb imatges)

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:12

Sempre he volgut comprar un kit de bateria des de petit. Aleshores, tots els equips musicals no tenien totes les aplicacions digitals, ja que en tenim un munt d’avui, de manera que els preus i les expectatives eren massa elevats. Recentment he decidit comprar un kit de bateria més barat a eBay, amb l’única prioritat: la possibilitat d’enderrocar-lo i connectar el meu propi maquinari i programari al dispositiu.

La compra no va decebre en absolut: kit de bateria portàtil enrotllable amb 9 coixinets de so diferents, dos pedals d’interruptor de peu per a bateria de peu i caputxa i presa de corrent micro-USB. El que realment desmotivava, són els sons de sortida (l’ús real d’aquest kit és connectar altaveus externs i gaudir-ne). Per tant, vaig decidir convertir-lo al meu propi programable mitjançant USB, kit de bateria MIDI basat en Arduino i interfície d’usuari basat en Python, per a un ús pràctic i modificacions fàcils, com ara selecció de volum, nota i canal.

Característiques del dispositiu:

• Preu baix
• Creant un kit de bateria a partir de qualsevol entrada digital, fins i tot un conjunt de botons
• Suport de comunicació i alimentació mitjançant interfície USB només: integració del convertidor USB a UART i del dispositiu Arduino
• Peces Mininum per a un funcionament correcte
• Interfície d'usuari basada en Python fàcil d'utilitzar
• Suport MIDI complet amb velocitat, nota i pins Arduino ajustables
• Desa i carrega les configuracions de bateria personalitzades emmagatzemades a la memòria del dispositiu

Procedim al projecte …

Pas 1: teoria de l'operació

Diagrama de blocs

Primer de tot, centrem-nos en l’estructura del projecte i dividim-la en blocs separats:

Kit de bateria enrotllable

La unitat principal del projecte. Consisteix en 9 coixinets de bateria separats, on cada coixinet és un conjunt de botons que canvien el seu estat lògic mentre es premen. A causa de la seva estructura, hi ha la possibilitat de construir aquest kit de bateria en particular a partir de qualsevol botó polsador. Cada coixinet de bateria està connectat a la resistència de tracció de la placa electrònica principal, de manera que mentre es colpeja el coixinet de bateria repetidament, es connecta un commutador específic a la terra del circuit i hi ha LOW lògic a la línia de coixinet de tambor. Quan no s’aplica cap pressió, l’interruptor del tambor està obert i, a causa de la resistència a la línia elèctrica, hi ha HIGH lògic a la línia del tambor. Com que el propòsit del projecte és crear un dispositiu MIDI digital complet, es poden deixar de banda totes les parts analògiques del PCB principal. És important tenir en compte que el kit de bateria té dos pedals per a bombo i bombó, que també estan lligats a les resistències de tracció i comparteixen la mateixa lògica de funcionament que tots els tambors (ho parlarem una mica més tard).

Arduino Pro-Micro

El cervell de la bateria. El seu propòsit és detectar si surt un senyal d’un tambor i proporcionar una sortida MIDI adequada amb tots els paràmetres necessaris: Nota, velocitat i durada del senyal. A causa de la naturalesa digital de les pastilles de bateria, es poden lligar simplement a entrades digitals arduino (10 pins en total). Per tal d’emmagatzemar tots els paràmetres i la informació MIDI desitjats, utilitzarem la seva memòria: EEPROM, per tant, cada vegada que encenem el dispositiu, la informació MIDI s’està carregant des de EEPROM, de manera que es pot reprogramar i tornar a configurar. A més, Arduino Pro-Micro està disponible en un paquet molt petit i es pot assignar fàcilment a la caixa interior del kit de bateria.

FTDI USB a convertidor de sèrie

Per programar i definir les funcions del nostre dispositiu amb l’ajut de l’aplicació per a PC, cal convertir la interfície USB a sèrie, perquè Arduino Pro-Micro no té USB. Com que la comunicació entre dispositius es basa en UART, el dispositiu FTDI s'utilitza en aquest projecte, a causa de la seva simplicitat d'ús independentment de les seves propietats addicionals.

Aplicació per a PC: Python

Quan es tracta de desenvolupament d’interfícies d’usuari i projectes de construcció ràpida, Python és una solució excel·lent. L’objectiu de l’aplicació d’interfície d’usuari és fer molt més convenient redefinir les propietats MIDI del nostre kit de bateria, emmagatzemar informació, programar el dispositiu i fer comunicacions entre els sistemes sense necessitat de compilar el codi una vegada i una altra. Com que utilitzem la interfície sèrie per comunicar-nos amb el kit de bateria, hi ha un munt de mòduls gratuïts a tot Internet que admeten qualsevol tipus de comunicació en sèrie. A més, com es parlarà més endavant, la interfície UART consta de tres pins: RXD, TXD i DTR. DTR s’utilitza per fer el restabliment del mòdul Arduino, per tant, quan estem interessats en executar una aplicació MIDI o connectar la interfície d’usuari al dispositiu del programa, no hi ha cap necessitat de tornar a connectar el cable USB ni res.

Pas 2: Parts i instruments

Parts

• Kit de bateria enrotllable
• 2 pedals Sustain (normalment inclosos al paquet DK).
• FTDI: convertidor USB a sèrie
• Arduino Pro Micro
• Cable micro-USB

Instruments

• Soldador / Estació
• Estany de soldadura
• Fil de nucli simple de diàmetre prim
• Pinces
• Cortador
• Alicates
• Ganivet
• Tornavís
• Impressora 3D (opcional: per a plataformes de pedals personalitzades)

Programari

• IDE Arduino
• Python 3 o superior
• JetBrains Pycharm
• Interfície MIDI sense pèl
• loopMIDI

Pas 3: Soldadura i muntatge

Com que hi ha tres mòduls que s'han de combinar, el procés de soldadura i muntatge és breu i senzill:

• Connecteu Arduino Pro-Micro amb el dispositiu FTDI i assegureu-vos que les connexions compleixen les E / S definides a cada dispositiu:

  • VBUS-VBUS
  • GND-GND
  • DTR-DTR
  • RXD-TXD
  • TXD-RXD
• Traieu tots els cargols de la carcassa de plàstic del tambor, assegureu-vos que pugueu centrar-vos en el cable de placa a placa i les seves resistències de tracció

• Cables prims de soldadura per al mòdul Arduino-FTDI que hem construït anteriorment:

  • Entrades digitals: D [2:11]
  • VBUS
  • D +
  • D-
  • GND
• Introduïu el mòdul dins de la caixa de la bateria perquè els cables flotin al mateix costat que les resistències de tracció dels coixinets
• Soldeu totes les entrades digitals als terminals del tambor tal com es mostra a la darrera figura.
• Soldeu el bus micro-USB (VBUS, D +, D-, GND) al dispositiu FTDI, assegureu-vos que no hi hagi errors en traçar aquests cables.
• Connecteu el mòdul Arduino-FTDI amb cola calenta a la caixa de la bateria
• Muntatge del dispositiu amb un cargol adequat

Ho hem fet, el dispositiu està muntat. Continuem amb el codi …

Pas 4: Programació A: Arduino

Descrivim el nostre esbós pas a pas:

En primer lloc, cal incloure dues biblioteques necessàries per al bon funcionament. EEPROM ja està preinstal·lada a l'IDE Arduino, però el mòdul de desconnexió per a kick drum s'ha d'instal·lar per separat

#include #include

Aquests commutadors s'utilitzen principalment en seqüències de depuració. Si voleu provar la connexió dels terminals Arduino a les pastilles de bateria i determinar totes les entrades digitals, caldria definir aquests commutadors

/ * Commutadors de desenvolupador: descomenteu el mode desitjat per depurar o inicialitzar * /// # define LOAD_DEFAULT_VALUES // Carregueu valors constants en lloc d'EEPROM // # define PRINT_PADS_PIN_NUMBERS // Imprimiu el número de pin que està connectat a un pad que es va colpejar a través del port sèrie

Els camps constants representen tots els valors per defecte, inclosa l’enumeració del coixinet de bateria. Per fer funcionar el dispositiu per primera vegada, cal conèixer la connexió exacta dels pedals Hi-Hat i Kick

/ * Enumeració de tipus de tambor * /

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

/ * Valors predeterminats * /

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};

/ * Durada de la sortida de la bateria * /

const uint8_t KICK_DB_DURATION = 30;

EEPROM s'utilitza per emmagatzemar / carregar totes les dades provinents de l'aplicació de PC. L'abast de les adreces descrites anteriorment mostra la ubicació exacta de la informació MIDI per a cada tambor

/ * Mapatge d'adreces EEPROM

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

Pins: | 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13 | Velocitats | 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;

Les variables globals s’utilitzen per determinar l’estat de cada pad i realitzar la comunicació MIDI en conseqüència

/ * Variables globals * /

uint8_t drumNotes [10], drumVelocities [10], drumPins [10]; // Variables MIDI

uint8_t uartBuffer [64]; // UART Buffer per recollir i emmagatzemar MIDI Data Debouncer kick (DRUM_PINS [KICK], KICK_DB_DURATION); // Objecte debouncer per bool volàtil de kick drum anteriorState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Els estats lògics anteriors de la bateria del tambor són volàtils bool currentState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Estats lògics actuals del tambor

Funcions EEPROM

/ * Emmagatzema la configuració a EEPROM * /

void storeEEPROM () {

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

/ * Carregueu els paràmetres des de l'EEPROM * /

void loadEEPROM () {for (uint8_t i = 0; i <10; i ++) notes de bateria = EEPROM.read (NOTES_ADDR + i); per a (uint8_t i = 0; i <10; i ++) drumPins = EEPROM.read (PINS_ADDR + i); per a (uint8_t i = 0; i <10; i ++) drumVelocities = EEPROM.read (VELOCITIES_ADDR + i); }

La inicialització de variables i el mode de programació, en el cas dels pedals i l'arrencada d'Arduino s'activen simultàniament

void enterProgrammingMode () {

bool confirmBreak = fals; 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; altrament charCnt ++; }} Serial.println ("D'acord"); storeEEPROM (); }

void initValues () {

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

Controladors de comunicació MIDI amb retard de 1 ms de temps de retenció de notes

/ * Reprodueix la funció de notes MIDI * /

void midiOut (enum DRUM_POSITION drumIn) {

if (drumIn == HIHAT) {// Si es va colpejar HI-HAT, cal comprovar si es prem el pedal if (! digitalRead (drumPins [HIHAT_PEDAL])) {noteOn (0x90, drumNotes [HIHAT_PEDAL], drumVelocities [HIHAT_PEDAL]); retard (1); noteOn (0x90, drumNotes [HIHAT_PEDAL], 0); } else {noteOn (0x90, drumNotes [HIHAT], drumVelocities [HIHAT]); retard (1); noteOn (0x90, drumNotes [HIHAT], 0); }} else {// transmissió MIDI de bateria normal noteOn (0x90, notes de bateria [drumIn], drumVelocities [drumIn]); retard (1); noteOn (0x90, drumNotes [drumIn], 0); }}

void noteOn (int cmd, int pitch, int speed) {Serial.write (cmd); Serial.write (pitch); Serial.write (velocitat); }

setup () i loop () amb funcions infinites de funcionament del dispositiu:

configuració nul·la () {

Serial.begin (115200);

per a (uint8_t i = 0; i <10; i ++) {pinMode (i + 2, INPUT); } #ifdef PRINT_PADS_PIN_NUMBERS while (true) {// Bucle de depuració infinit per a (uint8_t i = 0; i <10; i ++) {if (! digitalRead (i + 2)) {Serial.print ("Pin No: D"); Serial.print (i + '0'); // Converteix el número en caràcter ASCII}}} #else initValues (); / * Mode de programació: si es premen dos pedals mentre arrenca: el mode està activat * / if (! DigitalRead (drumPins [KICK]) &&! DigitalRead (drumPins [HIHAT_PEDAL])) enterProgrammingMode (); #endif}

void loop () {for (uint8_t i = 1; i <9; i = i + 1) {currentState = digitalRead (drumPins ); if (! currentState && previousState ) midiOut (i); // Compareu els estats i detecteu la caiguda anteriorStat = currentState ; } kick.update (); // Kick drum utilitza un algorisme de rebounce personalitzat if (kick.edge ()) if (kick.falling ()) midiOut (KICK); }

Pas 5: Programació B: Python i interfície d'usuari

La interfície d'usuari de Python és una mica complicada d'entendre a primera vista, de manera que provaríem d'explicar-ne els conceptes bàsics, com s'utilitza, quina funció té cada botó i com programar correctament el dispositiu Arduino.

Interfície d'usuari: aplicació

La interfície d’usuari és una representació gràfica del nostre programador de bateries, cosa que fa que sigui molt fàcil d’utilitzar i que sigui convenient programar el dispositiu Arduino en qualsevol moment. La IU consta de diversos mòduls gràfics que estan lligats a la seva operació suggerida. revisem-los un per un:

1. Imatge del conjunt de bateria: la interfície d’usuari de Python utilitza coordenades d’imatges X-Y per determinar quin tipus de bateria s’ha seleccionat. Si es va seleccionar una regió de bateria vàlida, apareixerà un missatge IO secundari, amb camps de nota, velocitat i terminal Arduino per a una bateria dedicada. Després de verificar i aprovar aquests paràmetres, aquests valors es poden transmetre directament al dispositiu Arduino.
2. Imatge de controlador extern: per poder utilitzar el kit de bateria MIDI amb entorn de creació de VST / Music, cal executar un intèrpret de sèrie a MIDI. He utilitzat Hairless, que està disponible de forma gratuïta i que es pot executar directament des de la nostra interfície d’usuari, només prement la seva imatge.
3. Llista de ports COM: per comunicar-se amb Arduino, cal especificar el port COM adjunt. La llista s'està actualitzant prement el botó Actualitza.
4. Carrega / Desa la configuració: hi ha valors MIDI predeterminats definits al codi, que l'usuari pot modificar mitjançant la interacció amb la interfície d'usuari. La configuració es defineix al fitxer config.txt en un format específic, que l'usuari pot desar o carregar.
5. Botó del dispositiu del programa: per emmagatzemar tots els valors MIDI modificats a Arduino EEPROM, cal prémer dos pedals (Kick drum i Hi-hat pedal) després, espereu que finalitzi la transmissió de dades. Si hi ha hagut problemes de comunicació, es mostrarà una finestra emergent adequada. Si la transmissió té èxit, la IU mostrarà el missatge correcte.
6. Botó de sortida: només cal sortir de l'aplicació, amb el permís de l'usuari.

Aspectes destacats del codi Python

Hi ha moltes coses que passen al codi, de manera que ampliarem les funcions escrites en lloc de tot el codi.

En primer lloc, per utilitzar la interfície d’usuari, cal descarregar diversos mòduls perquè el codi funcioni:

importar importar filaments importar tkinter com tk des de tkinter importar bústia de missatges des de importar tkinter * des d'importar PIL ImageTk, importar imatges numpy com importar np importar glob globals

Alguns mòduls s’inclouen al paquet Python per defecte. S'han d'instal·lar diversos mòduls mitjançant l'eina PIP:

instal·lar pip Coixí

pip install numpy pip install ScreenInfo

Es recomana executar l'aplicació mitjançant PyCharm. En les versions futures, tinc previst exportar un executable per al projecte.

Explicació del codi breu

Serà molt més fàcil entendre el codi si mirem les seves línies des de la perspectiva de funcions i classes:

1. La funció principal: aquí comença el codi

if _name_ == '_main_': drumkit_gui ()

2. Constants, coordenades i informació MIDI predeterminada del kit de bateria

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

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

COORDENADES_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] DRUM_PINS = [8, 6, 4, 3, 11, 9, 5, 10, 2, 7]

3. Funcions de la IU: maneig de la interfície d'usuari i objectes gràfics

def set_active (ui)

def secundari_ui (tipus_tambor)

classe SelectionUi (tk. Frame)

classe Aplicació (tk. Frame)

def drumkit_gui ()

def event_ui_clicked (esdeveniment)

def getorigin (jo, esdeveniment)

4. Comunicació en sèrie

def get_serial_ports ()

def communication_with_arduino (port)

5. Treballar amb fitxers: emmagatzemar / carregar paràmetres des del fitxer txt

def save_config ()

def load_config ()

6. Execució de l'aplicació externa hairless.exe des del codi mitjançant les funcions de roscat de Python

classe ExternalExecutableThread (threading. Thread)

def run_hairless_executable ()

Per executar el codi, hi ha una llista de fitxers que cal adjuntar a la carpeta del projecte:

• config.txt: fitxer de configuració
• hairless.exe: convertidor MIDI sense pèl
• drumkit.png: imatge que defineix totes les pastilles de bateria on es pot fer clic a la nostra interfície d’usuari (s’ha de descarregar del conjunt d’imatges d’aquest pas)
• drumgui.py: el codi del projecte

Això és tot el que hem de destacar perquè funcioni. És molt important afegir fitxers al projecte: imatge del conjunt de bateries, executable hairless.exe i fitxer de configuració config.txt.

I.. Aquí ho hem fet!:)

Espero que us sigui útil.

Gràcies per llegir!:)