Set de baterii MIDI pe Python și Arduino: 5 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:42

Întotdeauna mi-am dorit să cumpăr o baterie de când eram copil. Pe atunci, toate echipamentele muzicale nu aveau toate aplicațiile digitale, deoarece avem o mulțime de astăzi, prin urmare, prețurile împreună cu așteptările erau prea mari. Recent, am decis să cumpăr un kit de baterii mai ieftin de la eBay, cu singura prioritate: Abilitatea de a-l rupe și de a atașa propriul meu hardware și software la dispozitiv.

Achiziția nu a fost deloc dezamăgitoare: kit portabil de tambur roll-up cu 9 plăci de sunet diferite, două pedale de comutator de picior pentru kick drum și hi-hat și priză de alimentare micro-USB. Ceea ce a fost într-adevăr demotivant, este sunetul de ieșire (utilizarea reală a acestui kit este să conectați difuzorul extern și să vă bucurați de el). Așadar, am decis să-l convertesc în propriul meu programabil prin USB, kit de baterie MIDI bazat pe Arduino și interfață de utilizator bazat pe Python, pentru o utilizare la îndemână și modificări ușoare, precum selecția de volum, notă și canal.

Caracteristicile dispozitivului:

• Preț scăzut
• Crearea unui kit de baterie din orice intrări digitale - chiar și o gamă de butoane
• Suport pentru comunicare și alimentare numai prin interfață USB - Integrarea convertorului USB la UART și a dispozitivului Arduino
• Piese Mininum pentru o funcționare corectă
• UI bazat pe Python ușor de utilizat
• Suport MIDI complet cu viteză reglabilă, note și pini Arduino
• Salvați și încărcați configurațiile de tambur personalizate stocate în memoria dispozitivului

Să continuăm cu proiectul …

Pasul 1: Teoria funcționării

Diagramă bloc

În primul rând, să ne concentrăm asupra structurii proiectului și să o împărțim în blocuri separate:

Set de tambur Roll-Up

Unitatea principală a proiectului. Se compune din 9 tampoane de tambur separate, unde fiecare pad este o serie de butoane care își schimbă starea logică în timp ce sunt lovite. Datorită structurii sale, există posibilitatea de a construi acest set special de baterii din orice butoane. Fiecare tampon de tambur este conectat la rezistența de tracțiune de pe placa electronică principală, astfel, în timp ce pad-ul de tambur este lovit în mod repetat, un comutator specific este legat la solul circuitului și LOW-ul logic este prezent pe linia tamponului de tambur. Atunci când nu există presiune aplicată, comutatorul tamponului tamburului este deschis și datorită rezistenței de tracțiune la linia de alimentare, pe linia tamponului tamburului este prezentă HIGH logică. Deoarece scopul proiectului este de a crea un dispozitiv digital MIDI complet, toate părțile analogice de pe placa principală pot fi neglijate. Este important de observat că trusa de drum are două pedale pentru tambur și hi-hat, care sunt, de asemenea, legate de rezistențele de tracțiune și împărtășesc aceeași logică de funcționare ca toate tampoanele de tambur (Vom discuta puțin mai târziu).

Arduino Pro-Micro

Creierul drumului. Scopul său este de a detecta dacă există un semnal care iese dintr-un tambur și de a oferi o ieșire MIDI adecvată cu toți parametrii necesari: Notă, viteză și durată a semnalului. Datorită naturii digitale a tampoanelor de tambur, acestea pot fi pur și simplu legate de intrările digitale arduino (10 pini în total). Pentru a stoca toate setările și informațiile MIDI dorite, vom folosi memoria sa - EEPROM, prin urmare, de fiecare dată când pornim dispozitivul, informațiile MIDI sunt încărcate din EEPROM, făcându-l reprogramabil și reconfigurabil. De asemenea, Arduino Pro-Micro este disponibil într-un pachet foarte mic și poate fi alocat cu ușurință în carcasa interioară a bateriei.

FTDI USB To Serial Converter

Pentru a programa și defini caracteristicile dispozitivului nostru cu ajutorul aplicației PC, este necesar să convertiți interfața USB în serie, deoarece Arduino Pro-Micro nu are USB. Deoarece comunicarea între dispozitive se bazează pe UART, dispozitivul FTDI este utilizat în acest proiect, datorită simplității sale de utilizare, indiferent de proprietățile sale suplimentare.

Aplicație PC - Python

Când vine vorba de dezvoltarea interfețelor utilizator și a proiectelor rapide de construit, Python este o soluție superbă. Scopul aplicației UI este de a face mult mai convenabil redefinirea proprietăților MIDI pentru kitul nostru de baterii, stocarea informațiilor, programarea dispozitivului și comunicarea între sisteme fără a fi necesară compilarea codului de mai multe ori. Deoarece folosim interfața serială pentru a comunica cu un kit de baterie, există o mulțime de module gratuite pe tot internetul, care acceptă orice tip de comunicație serială. În plus, așa cum va fi discutat mai târziu, interfața UART este formată din total de trei pini: RXD, TXD și DTR. DTR este folosit pentru a efectua resetarea pe modulul Arduino, astfel, atunci când suntem interesați să rulăm aplicația MIDI sau să conectăm UI la dispozitivul de programare, nu este absolut necesar să reatașați cablul USB sau orice altceva.

Pasul 2: Piese și instrumente

Părți

• Set de tambur Roll-Up
• 2 x Pedale Sustain (De obicei, incluse în pachetul DK).
• FTDI - Convertor USB către serie
• Arduino Pro Micro
• Cablu micro-USB

Instrumente

• Fier de lipit / Stație
• Tinut de lipit
• Fir subțire cu diametru subțire
• Pensetă
• Cutter
• Plier
• Cuţit
• Șurubelniță
• Imprimantă 3D (Opțional - pentru platforme de pedale personalizate)

Software

• IDE Arduino
• Python 3 sau mai mare
• JetBrains Pycharm
• Interfață MIDI fără păr
• loopMIDI

Pasul 3: lipire și asamblare

Deoarece există trei module care trebuie combinate, procesul de lipire și asamblare este scurt și simplu:

• Atașați împreună Arduino Pro-Micro cu dispozitivul FTDI, asigurați-vă că conexiunile sunt conforme I / O definite la fiecare dispozitiv:

  • VBUS-VBUS
  • GND-GND
  • DTR-DTR
  • RXD-TXD
  • TXD-RXD
• Îndepărtați toate șuruburile din carcasa din plastic a tamburului, asigurați-vă că vă puteți concentra pe cablul de la placă la placă și rezistențele sale de tragere

• Cabluri subțiri de lipit pentru modulul Arduino-FTDI pe care le-am construit anterior:

  • Intrări digitale: D [2:11]
  • VBUS
  • D +
  • D-
  • GND
• Introduceți modulul în interiorul carcasei bateriei, astfel încât firele să plutească pe aceeași parte ca și rezistențele de tracțiune ale tampoanelor
• Lipiți toate intrările digitale la terminalele tamponului de tambur așa cum se arată în ultima figură.
• Lipiți autobuzul micro-USB (VBUS, D +, D-, GND) către dispozitivul FTDI, asigurați-vă că nu există greșeli la urmărirea acestor fire.
• Atașați modulul Arduino-FTDI cu lipici fierbinte la carcasa bateriei
• Montați dispozitivul cu șuruburi adecvate

Am făcut-o, dispozitivul este asamblat. Să continuăm cu codul …

Pasul 4: Programarea A: Arduino

Să descriem schița noastră pas cu pas:

În primul rând, este necesar să se includă două biblioteci necesare pentru buna funcționare. EEPROM este deja preinstalată în IDE-ul Arduino, dar modulul debouncer pentru kick drum trebuie instalat separat

#include #include

Aceste comutatoare sunt utilizate în principal în secvențe de depanare. Dacă doriți să încercați conexiunea terminalelor Arduino la tampoanele de tambur și să determinați toate intrările digitale, aceste comutatoare ar trebui definite

/ * Comutatoare pentru dezvoltatori: Decomentați modul dorit pentru depanare sau inițializare * /// # define LOAD_DEFAULT_VALUES // Încărcați valori constante în loc de EEPROM // # define PRINT_PADS_PIN_NUMBERS // Tipăriți numărul pinului care este conectat la un pad care a fost lovit prin portul serial

Câmpurile constante reprezintă toate valorile implicite, inclusiv enumerarea drum pad-ului. Pentru a rula dispozitivul pentru prima dată, trebuie să cunoașteți exact conexiunea pedalelor Hi-Hat și Kick

/ * Enumerare tip tambur * /

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

/* Valori implicite */

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

/ * Durată de respingere a tamburului de lovitură * /

const uint8_t KICK_DB_DURATION = 30;

EEPROM este utilizată pentru a stoca / încărca toate datele provenite din aplicația PC. Intervalul de adrese descris mai sus, arată locația exactă a informațiilor MIDI pentru fiecare pad de tambur

/ * Cartografierea adreselor EEPROM

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

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

Variabilele globale sunt utilizate pentru a determina starea fiecărui pad și pentru a efectua comunicarea MIDI în consecință

/ * Variabile globale * /

uint8_t drumNote [10], drumVelocities [10], drumPins [10]; // Variabile MIDI

uint8_t uartBuffer [64]; // UART Buffer pentru colectarea și stocarea MIDI Data Debouncer kick (DRUM_PINS [KICK], KICK_DB_DURATION); // Obiect debouncer pentru bool volatil kick drum previousState [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Starea logică anterioară a tamburului starea curentă boolicăStat [9] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; // Stările logice curente ale tamburului

Funcții EEPROM

/ * Stocați setările în EEPROM * /

void storeEEPROM () {

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

/ * Încărcați setările din EEPROM * /

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

Inițializarea variabilelor și modul de programare, în cazul pedalelor și boot-ului Arduino sunt activate simultan

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”); magazinEEPROM (); }

voit initValues () {

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

Manipulatori de comunicații MIDI cu întârziere de 1 ms

/ * Redare funcție notă MIDI * /

void midiOut (enum DRUM_POSITION drumIn) {

if (drumIn == HIHAT) {// Dacă a fost lovit HI-HAT, este necesar să efectuați o verificare a apăsării pedalei dacă (! digitalRead (drumPins [HIHAT_PEDAL])) {noteOn (0x90, drumNotes [HIHAT_PEDAL], drumVelocities [HIHAT_PEDAL]); întârziere (1); noteOn (0x90, drumNotes [HIHAT_PEDAL], 0); } else {noteOn (0x90, drumNotes [HIHAT], drumVelocities [HIHAT]); întârziere (1); noteOn (0x90, drumNotes [HIHAT], 0); }} else {// Transmisie regulată MIDI noteOn (0x90, drumNotes [drumIn], drumVelocities [drumIn]); întârziere (1); noteOn (0x90, drumNotes [drumIn], 0); }}

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

funcțiile setup () și loop () cu buclă infinită de funcționare a dispozitivului:

configurare nulă () {

Serial.begin (115200);

pentru (uint8_t i = 0; i <10; i ++) {pinMode (i + 2, INPUT); } #ifdef PRINT_PADS_PIN_NUMBERS while (true) {// Buclă de depanare infinită pentru (uint8_t i = 0; i <10; i ++) {if (! digitalRead (i + 2)) {Serial.print ("Pin nr: D"); Serial.print (i + '0'); // Conversia numărului în caracter ASCII}}} #else initValues (); / * Mod programare: Dacă sunt apăsate două pedale în timpul pornirii - modul este 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); // Comparați stările și detectați marginea descendentă previousState = currentState ; } kick.update (); // Kick drum folosește algoritmul de debounce personalizat if (kick.edge ()) if (kick.falling ()) midiOut (KICK); }

Pasul 5: Programarea B: Python și interfața utilizatorului

Interfața de utilizare Python este puțin complicată de înțeles la prima vedere, prin urmare am încerca să explicăm elementele de bază ale acesteia, cum să folosim, ce funcție are fiecare buton și cum să programăm dispozitivul Arduino în mod corespunzător.

Interfață utilizator - Aplicație

UI este o reprezentare grafică pentru programatorul nostru de kituri de baterii, ceea ce îl face foarte ușor de utilizat și convenabil pentru a programa oricând dispozitivul Arduino. UI constă din mai multe module grafice care sunt legate de funcționarea lor sugerată. să le trecem în revistă unul câte unul:

1. Drum Set Image: Python UI folosește coordonatele imaginii X-Y pentru a determina ce tip de tambur a fost selectat. Dacă a fost selectată regiunea de tambur validă, apare mesajul IO secundar, cu câmpuri de notă, viteză și terminal Arduino pentru pad-ul de tambur dedicat. După ce acești parametri sunt verificați de către utilizator și aprobați, aceste valori pot fi transmise direct către dispozitivul Arduino.
2. Imagine a controlerului extern: Pentru a putea folosi kitul de baterie MIDI cu mediul de creare VST / Muzică, este necesar să rulați un interpret Serial-To-MIDI. Am folosit Hairless, care este disponibil gratuit și poate fi rulat direct din interfața noastră de utilizare, doar prin apăsarea imaginii sale.
3. Lista de porturi COM: Pentru a comunica cu Arduino, trebuie să specificați portul COM atașat. Lista este actualizată apăsând butonul Reîmprospătare.
4. Încărcare / Salvare configurație: Există valori MIDI implicite definite în cod, care pot fi modificate de utilizator prin interacțiunea cu interfața de utilizare. Configurarea este definită în fișierul config.txt într-un format specific, care poate fi salvat sau încărcat de utilizator.
5. Butonul Program Device: Pentru a stoca toate valorile MIDI modificate în Arduino EEPROM, este necesar să apăsați două pedale (Kick drum și Hi-hat pedal) după aceea, așteptați finalizarea transmiterii datelor. Dacă au existat probleme de comunicare, va apărea o fereastră pop-up adecvată. Dacă transmisia reușește, interfața de utilizare va afișa mesajul său de succes.
6. Buton Exit: Ieșiți din aplicație, cu permisiunea utilizatorului.

Aspecte esențiale ale codului Python

Există multe lucruri care se întâmplă în cod, așa că vom extinde mai degrabă funcțiile scrise decât întregul cod.

În primul rând, pentru a utiliza interfața de utilizare, este necesar să descărcați mai multe module, pentru ca codul să funcționeze:

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 series glob

Unele module sunt incluse în pachetul implicit Python. Mai multe module ar trebui instalate prin instrumentul PIP:

pip instala Pillow

pip install numpy pip install ScreenInfo

Este recomandat să rulați aplicația prin PyCharm. În versiunile viitoare, intenționez să export un executabil pentru proiect.

Explicație scurtă a codului

Va fi mult mai ușor să înțelegem codul dacă ne-am uita la liniile sale din perspectiva funcțiilor și claselor:

1. Funcția principală - aici începe codul

if _name_ == '_main_': drumkit_gui ()

2. Drum Kit constante, coordonate și informații MIDI implicite

clasa Tobe: DRUM_TYPES = ["Kick", "Hihat", "Snare", "Crash 1", "Crash 2", "Tom High", "Tom Mid", "Tom Low", "Ride", "Hihat Pedal" "," Controler "]

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

COORDONATE_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. Funcții UI - Manevrarea interfeței de utilizator și a obiectelor grafice

def set_active (ui)

def secundar_ui (tambur_tip)

clasa SelectionUi (tk. Frame)

clasă Aplicație (tk. Frame)

def drumkit_gui ()

def event_ui_clicked (eveniment)

def getorigin (sine, eveniment)

4. Comunicare în serie

def get_serial_ports ()

def communic_with_arduino (port)

5. Lucrul cu fișiere: stocați / încărcați setările din fișierul txt

def save_config ()

def load_config ()

6. Rularea aplicației externe hairless.exe din cod utilizând funcțiile Python Threading

clasa ExternalExecutableThread (threading. Thread)

def run_hairless_executable ()

Pentru a rula codul, există o listă de fișiere care trebuie atașate la folderul proiectului:

• config.txt: fișier de setări
• hairless.exe: Convertor MIDI fără păr
• drumkit.png: Imagine care definește toate tampoanele de tambur care pot fi făcute clic pe interfața noastră de utilizare (trebuie descărcată din setul de imagini din acest pas)
• drumgui.py: Codul proiectului

Asta este tot ce trebuie să subliniem pentru a-l face să funcționeze. Este foarte important să adăugați fișiere la proiect: imagine set tambur, executabil hairless.exe și fișier setări config.txt.

Și.. Iată ce am făcut!:)

Sper că veți găsi acest lucru util.

Mulțumesc pentru lectură!:)