Coagula MIDI Ribbon Controller 2.0

Qualche mese fa ho pubblicato un post su come realizzare un MIDI Ribbon controller con Arduino. Nel frattempo mi sono accorto di poter migliorare un paio di cose sia a livello Hardware che Software e inoltre sentivo la necessità di poter modificare diversi parametri senza dover ogni volta riprogramare Arduino. Infine ho sistemato il controller in un case, grazie soprattutto a Laura che l'ha realizzato. Quindi questa è la versione 2.0 del mio MIDI Ribbon Controller che finalmente diventa uno strumento molto più pratico.

NOTA: Non sono un esperto di elettronica quindi se decidete di realizzare questo progetto non sono responsabile di eventuali danni a computer, case, persone e animali che potrebbero derivare. Inoltre non escludo che ci siano errori nell'articolo che cercherò comunque di correggere.

UPDATE: Sta per uscire sul mercato un nuovo MIDI ribbon controller della Eowave con collegamenti USB e audio. Include anche un piccolo synth tipo theremin e un'area di controllo per gli effetti. Il prezzo è abbordabile (199 euro + tasse). Quindi per molti questa potrebbe essere la soluzione migliore.


Prima di tutto la lista dei componenti necessari per il nostro Coagula MIDI ribbon controller:

 

Questo è lo schema elettrico:

Nel disegno non avendo a disposizione le immagini dei due sensori ho usato quelle di un potenziometro e di un force sensor circolare.

I due sensori vanno attaccati l'uno sull'altro, mettendo sotto quello di pressione e sopra quello di posizione. Il sensore di pressione è più lungo di una decina di centimetri e potete tranquillamente tagliare la parte eccedente. Il sensore di forza ha solo due terminali senza polarità e quindi non c'è rischio di sbagliare, ma per il sensore di posizione state molto attenti: se sbagliate le connessioni rischiate di bruciarlo! A me è capitato, purtroppo!

Ricordatevi anche che non si devono saldare i sensori direttamente, ma dovete usare dei connettori. Io ho utilizzato come connettore un mezzo zoccolo per circuiti integrati.

Nello schema ho modificato la connessione del sensore di posizione in modo da rendere superflua la sua calibrazione e per evitare disturbi quando non viene premuto il sensore. Ma la vera novità è l'aggiunta di un display LCD compatibile Hitachi HD44780 e di 4 pulsanti per gestire un menu tramite il quale è possibile scegliere tra due diverse modalità di controllo, impostare diversi parametri MIDI, ed eventualmente ricalibrare il sensore di pressione.

Queste sono le funzioni dei 4 tasti:

  • pin8 = Su
  • pin9 = Giù
  • pin10 = Esc
  • pin11 = Enter

Tenendo premuto il tasto Enter appare il menu e tramite i tasti su e giù potete navigare tra le varie voci. Con il tasto Esc potete uscire dal menu senza salvare i valori. Tutti i valori settati vengono salvati nella memoria flash di Arduino e quindi non si perdono allo spegnimento dello stesso.


La modalità Playing 2 è uguale a quella della prima versione ovvero premendo il sensore viene inviato un comando Note On e spostando il dito si inviano dei comandi Control Change. Il note off viene inviato solo nel momento in cui si rilascia il sensore.

Nella modalità 1 premendo il sensore viene inviato un comando Note On e spostando il dito si suonano le altre note, come quando si scorrono i tasti di un pianoforte.

In ambedue le modalità vengono inviati anche dei Control Change in base alla pressione applicata sul sensore.

Tramite il menu è possibile settare il numero di Control Change associato al sensore di posizione (usato solo per il Playing mode 2), il Control Change associato al sensore di forza, la nota più bassa e la più alta inviabile, il canale midi di trasmissione. Inoltre si può lanciare una modalità "MIDI Teach" che serve per inviare alcuni valori per i Control Change associati ai sensori, tramite i due tasti normalmente usati per andare su e giù nel menu. Tale modalità MIDI Teach è utile per sfruttare il MIDI Learn presente in moltissimi software musicali e moduli hardware, infatti, premendo i sensori, sarebbe impossibile inviare questi Control Change singolarmente e senza inviare anche dei MIDI Notes.

Infine da Menu è possibile anche lanciare la procedura di calibrazione del sensore di forza, che comunque viene eseguita in automatico la prima volta che avviate la scheda programmata.


Qui potete scaricare il codice completo. Avete bisogno anche della libreria MIDILIBRARY che potete scaricare direttamente da Sourceforge, e della libreria Menubackend di Alexander Brevig di cui dovete scaricare la versione 1.4 e modificarla leggermente aggiungendo, alla riga 195 del file MenuBackend.h subito prima della riga con scritto "private:", questo metodo:
    void toRoot() {
        setCurrent( &getRoot() );
    }
Tale metodo serve per poter tornare agevolmente alla radice del menu. Nello sketch dovete importare la libreria Menubackend così modificata, la Midilibrary e la libreria LiquidCrystal che è inclusa nell'IDE di Arduino.

Per maggiori dettagli sulla gestione del menu potete vedere il mio altro post su come gestire menu con Arduino.

Se doveste realizzare questo progetto o se doveste modificarlo sarei felice di vedere i risultati.

Ecco qui una piccola demo del MIDI Ribbon controller.

Il software utilizzato è Ableton Live e il plugin collegato al controller è Reaktor con l'ensemble Grobian e preset Daft. Il parametro HTr è stato associato al Control Change del sensore di pressione. Ho cercato di ottenere un effetto simile a quello dello Swarmatron usato da Trent Reznor.

 

Licenza Creative Commons
Coagula Arduino MIDI Ribbon Controller 2.0 by Giuseppe Di Cillo - Coagula.org is licensed under a Creative Commons Attribuzione - Non commerciale - Condividi allo stesso modo 3.0 Unported License.
Permissions beyond the scope of this license may be available at http://www.coagula.org/it.

Commenti(22)

Ciao volevo chiederti se potevi mandarmi la parte di programma che fa in modo che variando solo il sensore di posizione lasciando perdere quello di forza che non ne sono in possesso comunica note ad un synth software o una tastiera fisica esterna in base alla distanza. Piu Chealtro non riesco a capire tutte le parti di codice da estrapolare dalla versione due per fare questo.
Grazie mille

In realtà non ne hai bisogno. Ti basta far ignorare alla tastiera il messaggio inviato dal sensore di pressione.

ciao! sto facendo una cosa simile anche io però utilizzando un sensore di posizione come il tuo e un sensore di pressione di quelli circolari.
Il mio problema è che il sensore di posizione mi lascia sempre un rumore di fondo non so come eliminarlo...hai qualche consiglio??

Prova ad abbassare la resistenza da 1 Mh a 100kh. Il sensore risulterà meno lineare ma il rumore di fondo dovrebbe migliorare.

Ciao se volessi collegare lo strumento al posto che in midi con una presa usb come faccio?

E' necessario caricare un firmware per trasformare Arduino in dispositivo MIDI.

Davvero molto bello :) complimenti! Sto provando a rifarlo però avrei una domanda da farti. Premetto che ho seguito la prima versione del tuo progetto orientandomi anche con questa seconda versione. Una volta che è tutto assemblato attacco il Ribbon al mio Mac usando GarageBand, che riceve senza problemi il MIDI. Purtroppo però non ho lo stesso effetto "slide" del tuo, per passare da una nota all'altra devo staccare le dita come una normale tastiera.. Hai qualche suggerimento da darmi?

Con la modalità 1 non dovresti avere questo problema: le note dovrebbero suonare una dietro l'altra anche senza staccare il dito. Per ottenere l'effetto slide comunque tutto dipende dal tipo di synth utilizzato! Nella demo dell'articolo ho utilizzato un synth che si prestava bene, quindi il mio consiglio è di provare un pò con tutti i synth che hai a disposizione per cercare quello più adatto.

Ciao, io ho provato a caricareil codice da te indicato ma ricevo i seguenti errori alla verifica:

libraries\MIDI_1\MIDI.cpp:23:25: error: WConstants.h: No such file or directory
libraries\MIDI_1\MIDI.cpp: In member function 'void MIDI_Class::send(byte, byte, byte, byte)':
libraries\MIDI_1\MIDI.cpp:85: error: 'BYTE' was not declared in this scope
libraries\MIDI_1\MIDI.cpp:91: error: 'BYTE' was not declared in this scope
libraries\MIDI_1\MIDI.cpp:98: error: 'BYTE' was not declared in this scope
libraries\MIDI_1\MIDI.cpp:105: error: 'BYTE' was not declared in this scope
libraries\MIDI_1\MIDI.cpp: In member function 'void MIDI_Class::sendSysEx(byte, byte*)':
libraries\MIDI_1\MIDI.cpp:138: error: 'BYTE' was not declared in this scope

Io ho scaricato la libreria midi al link sopra, ma non essendo un esperto non so come risolvere questi errori.

un aiutino?

grazie in anticipo

Probabilmente hai installato sulla tua macchina due librerie MIDI tutte e due con all'interno il file "MIDI.h". Se cancelli (magari ne fai un backup prima per sicurezza) la cartella MIDI_1 dalle librerie dovrebbe funzionare tutto

Ciao,

innanzitutto grazie per la risposta. Ho effettuato l'operazione da te descritta ma mi da gli stessi errori.

Saluti,

Marzio

Cioè hai cancellato MIDI_1 e continua a darti lo stesso identico errore con nel percorso MIDI_1? Sei sicuro che non ci sia qualche altra libreria con all'interno un file MIDI.H?

Ciao,

no mi da gli stessi errori:

libraries\MIDI\MIDI.cpp:23:25: error: WConstants.h: No such file or directory
libraries\MIDI\MIDI.cpp: In member function 'void MIDI_Class::send(byte, byte, byte, byte)':
libraries\MIDI\MIDI.cpp:85: error: 'BYTE' was not declared in this scope
libraries\MIDI\MIDI.cpp:91: error: 'BYTE' was not declared in this scope
libraries\MIDI\MIDI.cpp:98: error: 'BYTE' was not declared in this scope
libraries\MIDI\MIDI.cpp:105: error: 'BYTE' was not declared in this scope
libraries\MIDI\MIDI.cpp: In member function 'void MIDI_Class::sendSysEx(byte, byte*)':
libraries\MIDI\MIDI.cpp:138: error: 'BYTE' was not declared in this scope

anche se provo a caricare solo gli sketch MIDI mi da questi errori. Crystal liquid e menubackend non trova errori.

ho installato arduino ide 1.0.1

Cancella la MIDI library e reinstalla quella linkata nel post.

Ciao,
ho una tastiera che monta un pitch bend whell di questo tipo

http://www.newgroove.it/dett_articolo.php?rep=4&sec=MASTERKE&cat=ACCESSO...

e vorrei sostituirlo con un ribbon controller.
Ti chiedo se basta sostiruire con un Ribbon sensor della Spectra Symbol lungo 10cm o devo muovermi diversamente.

Grazie

Purtroppo non posso risponderti con certezza senza conoscere lo schema elettrico della tastiera. Ma ad occhio non sono la stessa cosa perchè questa wheel usa solo una piccola parte della corsa del potenziometro.

Ciao Giuseppe
Intanto ti invio la correzione per far si che il Mode1 si comporti allo stesso modo ma,senza il problema del release.
A me così sembra funzionare meglio ma...chiaramente a discrezione del consumatore

modifica Mode 1:
if (sensorPositionValue!=lastNote){ //if changed
MIDI.sendNoteOff(lastNote,0,midiChannel); // Stop the note
MIDI.sendNoteOn(sensorPositionValue,sensorForceValue,midiChannel); // Send a Note (pitch 42, velo 127 on channel 1)
lastNote=sensorPositionValue; // register the played note in order to stop it later
}
}

Invece per avere la possibilità di controllare tutti i synth in Mode2 (dove a me funziona solo col Kurzweil K2500 che infatti ha implemento sia il cc21 che è proprio assegnato sulla macchina per il controllo di pitch sia due pagine di editing per configurazioni Ribbon)
Premetto che ho oltre 30 synth e di 30 solo il Kurzweil va.
Allora ho provato ad assegnare il controllo di Pitch bend e parzialmente sono riuscito.
Poi fortunatamente ho trovato un source code in rete che ha confermato la mia idea del pitch bend .
E cioè che con questo tipo di assegnazione (messaggio pitchbend) al sensore di Pitch riesce a controllare la totalita dei synth.
Ora il mio ultimo problema è riuscire ad implementare questo void all'interno del (MODE4).Dico mode 4 perchè al Mode 3 ho messo la copia del Mode 1 ma modificata senza il problema del rilascio.Questo perchè ho notato che il difetto di release del mode 1 alcune volte crea sonorità interessanti e quindi ,ho deciso di implementare la correzione come mode3
Quindi come dicevo Sono riuscito a creare tutta la pagina Mode4 sia graficamente che come controllo(in pratica appare sul display ed e gestibile dai tasti) ma ho non poche difficolta ad inserirvi il source code completo trovato in rete per la gestione del pitchbend.
Almeno fin ora non ci sono riuscito ma,sono anche solo 3 giorni che mi sono avvicinato ad Arduino e quindi ...
Intanto allego il source code per il controllo del pitch bend.
Poi appena ho un attimo ti mando anche le foto
Ciao Grazie
Matteo

CONTROLLO PITCHBEND TROVATO IN RETE

/**********************************************************
* NAME: Ribbon/Softpot Controller forSound Generation via MIDI
* WRITTEN BY: TOM SCARFF
* DATE: 20/2/2009
* FILE SAVED AS: midi_ribbon_controller.pde
* FOR: Miduino ATmega168
* CLOCK: 16.00 MHz CRYSTAL
* PROGRAMME FUNCTION: Trigger a MIDI Sound,
* depending on ribbon/softPot voltage level when pushed,
* and generate Pitch Bend while Note is ON.
*
**************************************************************************/

// analog Thresholds for softPot sensing
#define softPotThreshold_ON 100
#define softPotThreshold_OFF 10
#define startNote 60
#define Bounce_Period 15
#define Pitch_Bend_Sensitivity 2
#define Program 50

int softPotPin = 0; // softPot connected to analog pin 0
int LedPin = 13; // LED connected to digital pin 13
byte softPotState=0;
byte x;
byte MIDIchannel;
byte velocity=127;
byte note_onoff;
int bend;
int val_noteOn;
int val_now=0x7f;
int val;

void setup() // run once, when the sketch previouss
{
pinMode(4, INPUT); // Set Inputs for 4 way DIP Switch
pinMode(5, INPUT);
pinMode(6, INPUT);
pinMode(7, INPUT);
digitalWrite(4, HIGH); // Set inputs Pull-up resistors High
digitalWrite(5, HIGH);
digitalWrite(6, HIGH);
digitalWrite(7, HIGH);

Serial.begin(31250);
pinMode(LedPin, OUTPUT); // sets the digital pin as output

for (x=1; x<=4; x++){
digitalWrite( LedPin, HIGH );
delay(300);
digitalWrite( LedPin, LOW );
delay(300);
}

midiSend( 0xC0 | MIDIchannel, Program );
}

void loop() // run over and over again
{
// Read 4-way DIP switch
MIDIchannel=digitalRead(4) + (digitalRead(5)<<1) + (digitalRead(6)<<2) + (digitalRead(7)<<3);

val = analogRead(softPotPin); // read voltage on analog pin 0

if( val >= softPotThreshold_ON && softPotState==0) {

note_onoff=val/64 + startNote; // 0 to 15 + 60
noteOn(MIDIchannel, note_onoff, velocity);
softPotState=0xff;

pitch_bend_test();

}

if( val <= softPotThreshold_OFF && softPotState>0 ) {
noteOff(MIDIchannel, note_onoff, velocity);
softPotState=0;
}

delay(Bounce_Period);
}

//++++++++++++++++++++++Functions++++++++++++++++++++++++++++++++++++++++

// Send a MIDI note-on message.
void noteOn(byte channel, byte note, byte velocity) {
midiMsg( (0x90 | channel), note, velocity);
}

// Send a MIDI note-off message.
void noteOff(byte channel, byte note, byte velocity) {
midiMsg( (0x80 | channel), note, velocity);
}

// Send a MIDI Pitch bend message.
void pitch_bend(byte channel, byte LSB, byte MSB) {
midiMsg( (0xE0 | channel), LSB, MSB); // set LSB = 0
}

// Send a two byte midi message
void midiSend(byte status, byte data ) {
Serial.print(status, BYTE);
Serial.print(data, BYTE);
}

// Send a general MIDI message
void midiMsg(byte cmd, byte data1, byte data2) {
digitalWrite(LedPin,HIGH); // indicate we're sending MIDI data
Serial.print(cmd, BYTE);
Serial.print(data1, BYTE);
Serial.print(data2, BYTE);
digitalWrite(LedPin,LOW);
}
//------------------------------------------------------------------

void pitch_bend_test(){

val_noteOn = analogRead(softPotPin)/Pitch_Bend_Sensitivity; // read voltage on analog pin 0 range 0 to 1023

while(val >= softPotThreshold_ON){
val_now = analogRead(softPotPin)/Pitch_Bend_Sensitivity; // read voltage on analog pin 0 range 0 to 1023

if(val_now > val_noteOn){
bend = (val_now - val_noteOn) + 64;
bend = bend & 0x007F;
pitch_bend(MIDIchannel,0x00, bend);
}

if(val_now < val_noteOn){
bend = 64 - (val_noteOn - val_now);
bend = bend & 0x007F;
pitch_bend(MIDIchannel,0x00, bend);
}

delay(Bounce_Period);
val = analogRead(softPotPin); // read voltage on analog pin 0
}

}

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Ciao Matteo,
grazie mille per aver condiviso questo codice, ottimo lavoro. Spero di trovare presto il tempo per provarlo.

Salve
Prima di tutto ringrazio per la possibilità che hai dato a tutti nel costruire questo ribbon controll.
Scrivo qui perchè non trovo un email privata sul quale farlo
Ho qualche problema.
Provo a far funzionare il ribbon con la midi library 3.0 o 3.1 o 3.1.1 ma l'unica che fa funzionare(ma male) il ribbon è la midi library 2.5.
Con la 3.1.1 sembra funzionare,sul display scrive DATA SENDING ma nessun segnale midi in realtà esce dal connettore din (ho provato anche col computer con un midi monitor a verificare la presenza di emissione di dati)
Con la library 2.5 funziona ma male perchè presenta due problemi fondamentali.
Il primo è che rilasciando il dito dai sensori viene emessa una nota ,praticamente se premo il dito emette una nota ma, anche quando rilascio emette una nota.
Il secondo problema è che muovendo il dito sul sensore di pitch ,il controllo sul suono utilizzato non interviene graduale (tipo glide,portamento o pitchbend se vogliamo) ma cambia proporzionalmente nota per nota successiva.In pratica non allunga il suono ma suona in sequenza le note senza nessun effetto di LEGATO tra una tonalità e l'altra.
Chiedo quindi se possibile qualche suggerimento visto che non riesco ,dopo due giorni,a trovare uscita.
Ho anche realizzato il mobile con un macchinario a controllo incassando i sensori così da portarli al livello del legno dove alloggiano.
Posso anche inviare foto se mi date modo
In attesa di una cortese risposta
ringrazio nuovamente
Matteo

Le tue osservazioni sulle librerie sono giuste: effettivamente per via delle dimensioni dello sketch e delle librerie al momento è possibile utilizzare solo la 2.5.
Per ridurre al minimo il problema della nota al rilascio è necessario modificare la resistenza da 1 megaohm con una da 100 kohm o adirittura da 10 kohm. Così facendo però la scala risulterà meno "lineare" e più "logaritmica" ovvero le note diventeranno più vicine man mano che ci si avvicina alle note più alte.
Il secondo problema in realtà deriva dal synth utilizzato. Devi trovare trai i tuoi synth uno che abbia un passaggio morbido tra una nota e l'altra. Alcuni plugin si adattano meglio di altri.
Per le foto e altro puoi inviarmele a info@coagula.org. Sono molto curioso :-)
Negli ultimi giorni ho modificato un pò lo sketch e al più presto scriverò una nuova versione di questo post con queste ultime indicazioni.
Ciao.

Bell'articolo davvero, l'ho trovato per caso e credo che mi costruirò un ribbon anche io :P
Per caso c'è modo di attaccarci una usb invece che un connettore midi? Altrimenti vado di adattatore MIDI/Usb.

Ho fatto qualche esperimento con un firmware per usarlo via usb ma risulta molto instabile. Ci riproverò in futuro.

Invia nuovo commento

CAPTCHA
Questa domanda serve per verificare che tu non sia uno spammer automatico.
Image CAPTCHA
Inserisci i caratteri e i numeri visualizzati nell'immagine.