Inversione della scala su tastiera MIDI

L’ applicazione può sembrare stravagante ma è una occasione per vedere come trattare i dati midi a proprio uso.

Introduzione

Qualche tempo fa, su un forum di elettronica, è stato aperto un Thread da un utente mancino che voleva sapere se era possibile utilizzare la tastiera con progressione delle note invertita, cioè da destra a sinistra, un po’ come si fa nelle chitarre per mancini.

Ovviamente il dibattito è proceduto nel senso che tutti i tastieristi conosciuti, sia destri che mancini, suonano tutti con lo stesso tipo di tastiera.

Alla discussione si è aggiunto un altro utente a difesa della possibilità di utilizzare la scala invertita, motivandola con il fatto che comunque un mancino ha un migliore controllo e naturalmente una maggiore velocità e precisione con la mano sinistra.

Questo utente mi ha contattato privatamente e mi ha chiesto se era possibile realizzare questa modifica, per lui importante.

In effetti la sua idea stava su delle basi concrete ed era motivata dal fatto che in realtà la tastiera è speculare, basta considerare il MI come un DO, e me lo ha dimostrato con questo semplice schemino:

Naturalmente ho detto che se aveva una master Keyboard bastava intercettare il messaggio, e modificarlo.

Purtroppo la sua tastiera è proprio un sintetizzatore, neanche da ridere, e giustamente lo vuole sfruttare così com’ è.

La prima cosa che mi è venuta in mente è stata quella di attivare il comando “LOCAL OFF”, che dovrebbe essere presente su tutte le tastiere MIDI, e che consente di dividere lo strumento in due moduli: la tastiera come generatore di eventi MIDI, e il sintetizzatore come modulo sonoro (una sorta di expander).

A quel punto basta prendere il messaggio MIDI inviato dalla tastiera, modificarlo e inviarlo al modulo sonoro.

La particolarità è che per fare tutto questo non serve neanche chissà quale software, basta riconoscere il valore della nota e fare: 124-val_nota, e si ottiene la scala invertita con il DO al posto del MI e via di seguito.

Il circuitino per realizzare il tutto è incentrato su un PIC16F628A, con un clock a 10MHz, lo schema è il seguente:

L’ immagine è sicuramente poco leggibile, per cui allego il PDF:

Keyb_Inv

Premessa: non ho usato un 7905 al posto di un 7805 perchè sono un tipo originale, semplicemente avevo solo quello.

Anche per quanto riguarda la realizzazione, non mi sono dannato l’ anima a fare un circuito stampato, ma una millefori pure montata così così:

Ai due morsetti viene applicata la tensione di alimentazione (il morsetto in alto è il positivo) tra i 9 e 12Vdc, oppure in alternata tra i 6 e 9Veff. In realtà si può anche superare la tensione massima di alimentazione in quanto non c’ è un grande passaggio di corrente.

I due cavi neri sono: quello in alto il MIDI IN (da collegare al MIDI OUT della tastiera), ovviamente l’ altro è il MIDI OUT (da collegare al MIDI IN della tastiera).

Prove

Per provare il funzionamento del circuito ho utilizzato un sequencer (Cubase), un convertitore USB-MIDI, ovviamente l’ oscilloscopio.

Il setup di prova è quello visibile di seguito:

Per eseguire la prova, molto semplicemente ho inserito in una traccia del sequencer una serie di note, dopodichè ho messo in Play quella traccia, il flusso di dati l’ ho fatto processare dal circuito, l’ ho rimandato al sequencer e ho fattoregistrare il risultato su un’ altra traccia.

Il risultato ottenuto è illustrato nell’ immagine seguente:

Nell’ immagine gli eventi grigi sono quelli preregistrati, mentre quelli rossi sono ottenuti dopo il reversing della scala.

Si può notare un certo ritardo, che è intrinseco nella fase di elaborazione, e in quella di trasferimento del segnale che viene isolato otticamente, e quindi di fatto ritardato. Occorre inoltre dire che il ritardo in registrazione dipende anche dalla quantizzazione della registrazione del sequencer, ad ogni modo non dovrebbe influenzare sull’ esecuzione di un brano.

Un’ altra immagine presa dalla videata principale di Cubase:

Infine quella che rende meglio l’ idea, lo score editor:

Per completezza allego la schermata dell’ oscilloscopio:

Come si può vedere il ritardo tra il dato entrante (traccia superiore) e il dato uscente (traccia inferiore), è circa quello di un byte.

Il software

Ho sviluppato questo “complicatissimo” firmware in Pascal (MikroPascal), di seguito il listato:


program NIKKE;
var
event : byte; absolute $20;
get_midi : byte; absolute $21;
run_stat : byte; absolute $22;
//**************************************************************************
//Procedure e Function
//**************************************************************************
procedure nota_on();
begin
run_stat := $90; //Note ON/OFF
usart_write(event);
end;
//***************************************************************************
procedure nota_off();
begin
run_stat := $80; //Note OFF
usart_write(event);
end;
//**************************************************************************
//Main Program
//**************************************************************************
begin //Main
run_stat := 0;
trisa := %11111111;
trisb := %01000010; //***********************************
//RB0 = Note OUT
//RB1 = Midi In IN
//RB2 = Toggle Sync OUT
//RB3 = Key Velocity OUT
//RB4 = Pitch Bend OUT
//RB5 = Gate OUT
//RB6 = 8th/16th 1=16th IN
//RB7 = Data Out 5 OUT
//RA0 = Data Out 0 OUT
//RA1 = Data Out 1 OUT
//RA2 = Data Out 2 OUT
//RA3 = Data Out 3 OUT
//RA4 = Data Out 4 Out
//RA5 = Legato/Staccato 1=Leg IN
//RA6 = Data Out 6 OUT
//RA7 = Clock IN
usart_init(31250); //Inizializza la linea midi a 31250 baud
portb := %00011001;
cmcon := %00000111;
while true do
begin
if usart_data_ready = 1 then //Verifica se è arrivato un dato
begin //E' arrivato un dato valido
get_midi := usart_read; //Legge il dato midi
event := get_midi;
if get_midi < $80 then //Running Status
begin
case run_stat of
$90: begin
event := 124 - event;
usart_write(event);
run_stat := $91;
end;
$91: begin
usart_write(event);
run_stat := $90;
end;
$80: begin
event := 124 - event;
usart_write(event);
run_stat := $81 ;
end;
$81: begin
usart_write(event);
run_stat := $80;
end;
$0: usart_write(event);
end;
end
else
begin
if get_midi < $F8 then get_midi := get_midi and $F0;
case get_midi of
$90: nota_on();
$80: nota_off()
else begin
run_stat := 0;
usart_write(event);
end;
end;
end;
end;
end;
end.

Data la scarsa leggibilità allego tutto il progetto sotware in fomato .zip

Keyb_Inv

Lavoro finito

Oggi 16-03-2011, si è finalmente conclusa la collaborazione con Nikke, che se magari non è un espertissimo di elettronica, con le scatole se la cava proprio bene.

Innanzitutto ha provveduto ad installare un trasformatore per alimentare il tutto, ha effettivamente usato una tensione un po’ alta (13Vac), ma ha verificato che l’ oggetto anche dopo molte ore di funzionamento non scaldava:

Un particolare del trasformatore:

E poi ha iniziato col farsi la scatola:

E ad allogiarvi l’ elettronica:

E il risultato finale:

Conclusioni

L’ oggetto è stato realizzato e a quanto pare funziona, va detto che questo semplicissimo accorgimento può trovare molte espansioni, ad esempio suonare gli accordi con un dito, arpeggi automatici, trasposizione di scale, e molte altre applicazioni.