Maak je eigen MIDI-controller met Arduino

Als u een muziekliefhebber bent of direct een amateur- of professionele muzikant, heeft u bij u thuis zeker een grote verzameling muziekinstrumenten verzameld. Om al deze mixen perfect te maken, is het het beste om een MIDI-controller. Helaas zijn dit soort objecten meestal vrij duur, zodat een persoon zonder al te veel middelen moeilijk toegang heeft tot alles wat ze te bieden hebben.

Om veel beter te begrijpen wat een MIDI-controller is, moet u zeggen dat het woord MIDI vandaan komt Muziekinstrument digitale interface, dat wil zeggen, een soort controller die ervoor zorgt dat elektronische muziekapparaten met elkaar kunnen communiceren. Als je bijvoorbeeld thuis een elektronisch keyboard hebt, is de kans groot dat deze een MIDI-interface heeft. Alvorens verder te gaan, ondanks het feit dat er bepaalde technische details zijn die ertoe kunnen leiden dat iemand anders denkt, moet het heel duidelijk zijn dat MIDI is geen audio.

Creëer je eigen MIDI-controller met deze eenvoudige tutorial

Als we hier eenmaal duidelijk over zijn, zal het zeker veel gemakkelijker voor u zijn om te begrijpen dat MIDI slechts een simpele is instructieset die tot 16 onafhankelijke kanalen kan ondersteunen, wat betekent dat er maximaal 16 verschillende apparaten onafhankelijk met elkaar kunnen communiceren. Deze apparaten moeten worden aangesloten via een 5-pins DIN-kabel, wat in feite een kabel is met vijf pinnen in een connector. Als detail is het vrij gebruikelijk om een ​​USB te gebruiken in plaats van een 5-pins DIN, in het geval van een USB moeten we een USB-MIDI-interface maken.

Zonder verder oponthoud laat ik je achter met de link waar je het zelfstudie stap voor stap met veel beschrijvende afbeeldingen waar we alle noodzakelijke acties kunnen uitvoeren om onze eigen MIDI-controller te creëren.

Gerelateerd artikel:

Hoe de Pi-gebruikersnaam en het wachtwoord op onze Raspberry Pi te wijzigen

Hoe maak je je eigen MIDI-controller met Arduino

Er zijn veel mensen die om verschillende redenen, zowel persoonlijk als professioneel, een volledig aangepaste MIDI-controller Omdat misschien en bijvoorbeeld op een bepaald punt in je leven als artiest, het kopen van een goedkope MIDI-controller misschien niet aan je verwachtingen of behoeften voldoet, terwijl, als de tijd daar is, het kiezen voor een professionele versie buitensporig kan zijn in beide financiële middelen. behoefte, evenals het grote aantal functies dat ze kunnen bieden.

Daarom wil ik je vandaag alles laten zien wat je nodig hebt, zodat je je eigen MIDI-controller kunt maken die zowel alles aangeeft wat nodig is voor de constructie als je de software aanbiedt die je nodig hebt om te installeren. Als detail is voor dit project het gebruik van een Arduino-bord essentieel, een controller die krachtig genoeg is om deze taak uit te voeren.

Gerelateerd artikel:

Hoe maak je een robot: 3 verschillende opties

Wat is een MIDI-controller?

In wezen is een MIDI-controller in grote lijnen verantwoordelijk voor het met elkaar verbinden van verschillende muziekapparaten. Er zijn veel instrumenten die een MIDI-interface bevatten, hoewel dit heel duidelijk moet zijn, aangezien er veel gebruikers zijn die vaak in de war zijn, MIDI is geen audiobestand, maar een heel eenvoudige set instructies die een instrument kan ontvangen. of geluidsinstellingen.

Binnen MIDI er zijn twee verschillende soortenEnerzijds hebben we die genaamd Change Control, waar deze het controllernummer en een waarde tussen 0 en 127 heeft. Hierdoor kunnen berichten worden verzonden waarin verschillende parameters zoals volume of toon kunnen worden gewijzigd. Verschillende instrumenten die MIDI accepteren, dienen een handleiding mee te nemen waarin wordt uitgelegd welke kanalen en berichten standaard zijn ingesteld en hoe u deze kunt wijzigen.

Op de tweede plaats hebben we de Program Change, een reeks berichten die op hun beurt veel eenvoudiger zijn dan die waaruit de Change Control bestaat. Dit soort berichten wordt gebruikt om de preset of patch van een apparaat te wijzigen. Net als bij Change Control moet de fabrikant naast uw instrument een handleiding bijvoegen die aangeeft welke presets door een bepaald bericht worden gewijzigd.

Onderdelen die nodig zijn om uw eigen zelfgemaakte MIDI-controller te bouwen

Om je eigen MIDI-controller te kunnen bouwen, heb je naast, zoals we al zeiden, een reeks stukken nodig op een Arduino-bord. Voordat je verder gaat, moet je je vertellen dat je misschien in de toekomst meer dingen nodig hebt, omdat je het project in de toekomst wilt uitbreiden, hoewel je op dit moment met een paar stukken genoeg zult hebben.

We hebben een 5-polige vrouwelijke DIN-kabel, 2 ohm weerstanden, 220 momentschakelaars, 2 2k ohm weerstanden, aansluitdraden, een printplaat, MIDI-kabel en een MIDI-apparaat of USB-interface nodig. Met alleen deze stukken kun je beginnen, door mijn stappen te volgen, om je eigen MIDI-controller te maken.

Eerste stappen

Voordat ik begin, laat ik je een foto achter waarop je de pinnen van je MIDI-kabel kunt zien, op deze manier kunnen we de pinnen correct identificeren en vooral waar ze elk moeten worden aangesloten. In grote lijnen hoef je op dit punt alleen maar pin 5 van de kabel aan te sluiten op een 220 ohm weerstand en van daaruit op de Arduino Transmit 1, pin 4 op een 220 ohm weerstand en van daaruit op de 5V aansluiting van Arduino terwijl pin 2 moet worden aangesloten op de massa-aansluiting van uw controller.

Zodra deze stap is voltooid, heb je geen gedetailleerd diagram op de foto die zich net onder deze lijnen bevindt, is het tijd om de knoppen aan te sluiten. Het idee in deze sectie is om met behulp van de digitalRead-pin (die kan detecteren wanneer de spanning die deze bereikt, verandert) te bereiken met een transistor, met slechts een druk op de knop. Hiervoor hoeven we alleen maar een knop te gebruiken zodat we de linkerkant ervan verbinden met 5V, de rechterkant met een weerstand van 220 ohm en van daaruit naar aarde terwijl we op onze beurt ook de rechterkant verbinden met pin 6 De tweede knop zou op dezelfde manier worden geïnstalleerd, hoewel, zoals je kunt zien in het diagram, we hem in plaats van pin 6 verbinden met 7.

Software om te gebruiken voor midi-controller thuis

Als we klaar zijn met alle hardware, is het tijd om ons instrument aan te sluiten en te testen. Daarvoor hebben we een USB-MIDI-interface en een MIDI-kabel om het bord, dat gegevens verzendt, te verbinden met onze computer. Om dit te bereiken, hebben we gekozen voor de MIDI v4.2-bibliotheek gemaakt door de jongens van Forty Seven Effects die we op onze Arduino moeten hebben geïnstalleerd en in het project moeten hebben opgenomen.

In het geval van de computer hebben we een programma nodig dat toezicht kan houden op alle MIDI-gegevens die erop binnenkomen vanuit Arduino. Hiervoor hebben we verschillende mogelijkheden zoals MIDI Monitor (OS X), MIDI-OX (Windows) of Kmidimon (Linux)

Om een ​​kleine test te doen, hoeven we alleen de Arduino op onze computer aan te sluiten en de volgende code uit te voeren:

#include
#include
#include
#include
#include

MIDI_CREATE_INSTANCE(HardwareSerial,Serial, midiOut); // crear objeto de salida MIDI llamado midiOut

void setup() {
Serial.begin(31250); // configuracion de serial para MIDI
}

void loop() {
midiOut.sendControlChange(56,127,1); // envío de señal MIDI CC -- 56 = nota, 127 = velocidad, 1 = canal
delay(1000); // retraso
midiOut.sendProgramChange(12,1); // envío de una señal MIDI PC -- 12 = valor, 1 = canal
delay(1000); // retraso de 1 segundo
}

Als alles goed is gegaan, kunt u naar de knoptest gaan, voor het geval deze test niet voor u heeft gewerkt, moet u ervoor zorgen dat alle aansluitingen correct zijn, het circuit is precies hetzelfde als het vorige diagram, het circuit is aangesloten op een USB-MIDI-interface met een MIDI-kabel, de MIDI-poortkabels zijn correct aangesloten, de MIDI-kabel is aangesloten op de ingang van de USB-MIDI-interface, het Arduino-bord is correct aangesloten op het elektrische netwerk en heeft voldoende stroom ...

Testen of de knoppen correct werken

Voordat we doorgaan met het voeden van ons programma met nieuwe functionaliteiten en code waarin we kunnen verdwalen, is het de moeite waard om even te stoppen en test of de knoppen goed werken. Voor hen moeten we de volgende code laden:

const int boton1 = 6; // asignacion del boton a una variable
const int boton2 = 7; // asignacion del boton a una variable

void setup() {
Serial.begin(9600); // configuracion del serial
pinMode(boton1,INPUT); // configuracion del boton1 como entrada
pinMode(boton2,INPUT); // configuracion del boton2 como entrada
}

void loop() {

if(digitalRead(boton1) == HIGH) { // prueba de estado del boton1
delay(10); // retraso
if(digitalRead(boton1) == HIGH) { // prueba de estado de nuevo
Serial.println("Boton 1 funciona correctamente!"); // log
delay(250);
}
}

if(digitalRead(boton2) == HIGH) { // prueba de boton 2
delay(10); // retraso
if(digitalRead(boton2) == HIGH) { // prueba de estado de nuevo
Serial.println("Boton 2 funciona correctamente!"); // log
delay(250);
}
}

}

Deze code hoeft alleen maar te worden gecompileerd en uitgevoerd, zodat het programma, met de USB-kabel aangesloten, aangeeft of er op een van de knoppen is gedrukt.

We maken onze zelfgemaakte MIDI-controller

Als we deze tests eenmaal hebben gedaan, is het tijd om daarvoor onze eigen MIDI-controller in elkaar te zetten, je hoeft alleen de volgende code te compileren:

#include
#include
#include
#include
#include

const int boton1 = 6; // asignamos boton a la variable
const int boton2 = 7; // asignamos boton a la variable

MIDI_CREATE_INSTANCE(HardwareSerial,Serial, midiOut); // create a MIDI object called midiOut

void setup() {
pinMode(boton1,INPUT); // configuracion del boton1 como una entrada
pinMode(boton2,INPUT); // configuracion del boton2 como una entrada
Serial.begin(31250); // configuracion MIDI de salida
}

void loop() {
if(digitalRead(buttonOne) == HIGH) { // comprobacion de estado
delay(10); // retraso
if(digitalRead(buttonOne) == HIGH) { // comprobacion de estado de nuevo
midiOut.sendControlChange(56,127,1); // envío un MIDI CC -- 56 = nota, 127 = velocidad, 1 = canal
delay(250);
}
}

if(digitalRead(buttonTwo) == HIGH) { // comprobacion de estado
delay(10); // retraso
if(digitalRead(buttonTwo) == HIGH) { // nueva comprobacion de estado
midiOut.sendControlChange(42,127,1); // envío un MIDI CC -- 42 = nota, 127 = velocidad, 1 = canal
delay(250);
}
}
}

Vertel je voor een detail dat je het Serial.println () commando deze keer niet kunt gebruiken met een MIDI-output, als je een soort bericht op de computer wilt laten zien, verander dan gewoon:

midiOut.sendControlChange(42,127,1);

door:

midiOut.sendControlChange(value, channel);

waarbij waarde en kanaal de gewenste waarden moeten hebben die u wilt weergeven.

Bedieningsvoorbeeld: