Piano digitale, sensitive velocity

Ciao a tutti ragazzi. In poche parole, sto cercando un modo con cui riuscire,a simulare un pianoforte reale. Mi spiego meglio, quando premo un tasto vorrei che a seconda della pressione usata, il suono si senta più o meno forte. Ho visto su google che questo è possibile con Arduino. Ecco qui, vi posto un video di come dovrebbe risultare alla fine. http://www.youtube.com/watch?v=nmIXKrA4-UA Aggiungo che non sono molto bravo ad utilizzare Arduino, anzi, ho davvero poca esperienza. Grazie dell' aiuto.

Il problema principale è l'attuatore, ossia il tasto che andrai a premere. Una prima idea può essere un potenziometro slider a corsa corta, tirato da una adeguata molla, messo in parallelo ad un microswitch di tipo fine-corsa per motori.

Il potenziometro regolerebbe il volume dell'amplificatore audio, mentre il microswitch, collegato ad arduino, genererebbe la nota.

La difficoltà è più manuale-meccanica che non elettronica.

Non so se queste aggiunzioni possano aiutarci.

Praticamente io ho collegato il piano digitale al computer (tramite un cavo midi) quindi uso un programma (vst) che simula il pianoforte appunto.
Ora, su questo vst, c’è un onda che regola l’intensità del suono a seconda della pressione effettuata su un tasto.
Ovviamente, il mio piano “digitale” non ha questa tecnologia, quindi, l’intensità del suono è sempre la stessa.

La soluzione che mi hai dato, mi sembra la più corretta,ma anche difficile da realizzare, o almeno per me.
Comunque ho anche trovato questa guida, che non so, se sia meglio dell’ altra ma provare non guasta.
Grazie ancora per l’aiuto :slight_smile:

// Pin Definitions
// Rows are connected to Digital
const int rowPin[] = { 6, 7, 8, 5 };
 
// FSRs connected to Analog
const int fsrPin[] = { 2, 3, 4, 5 };
 
// The 74HC595 uses a serial communication 
// link which has three pins
const int clock = 12;
const int latch = 13;
const int data = 11;
 
int keyToMidiMap[32];
 
boolean keyPressed[32];
int noteChannelPressed[4][64];
int notesChannel[4] = { 0, 0, 0, 0 };
 
 
// use prepared bit vectors instead of shifting bit left everytime
int bits[] = { B00000001, B00000010, B00000100, B00001000, B00010000, B00100000, B01000000, B10000000 };
int fsrValue[4];
 
unsigned long currentMillis;
unsigned long previousMillisChannel[4] = { 0, 0, 0, 0 };
 
// miliseconds delay before aftertouch sent
unsigned long expressionDelay=1000;
 
// 74HC595 shift to next column
void scanColumn(int value) {
  digitalWrite(latch, LOW); //Pulls the chips latch low
	shiftOut(data, clock, MSBFIRST, value); //Shifts out the 8 bits to the shift register
	digitalWrite(latch, HIGH); //Pulls the latch high displaying the data
}
 
void setup() {
	
	// Map scan matrix buttons/keys to actual Midi note number. Lowest num 41 corresponds to F MIDI note.
	keyToMidiMap[0] = 48;
	keyToMidiMap[1] = 41;
	keyToMidiMap[2] = 42;
	keyToMidiMap[3] = 43;
	keyToMidiMap[4] = 44;
	keyToMidiMap[5] = 45;
	keyToMidiMap[6] = 46;
	keyToMidiMap[7] = 47;
 
	keyToMidiMap[8] = 56;
	keyToMidiMap[1 + 8] = 49;
	keyToMidiMap[2 + 8] = 50;
	keyToMidiMap[3 + 8] = 51;
	keyToMidiMap[4 + 8] = 52;
	keyToMidiMap[5 + 8] = 53;
	keyToMidiMap[6 + 8] = 54;
	keyToMidiMap[7 + 8] = 55;
 
	keyToMidiMap[16] = 64;
	keyToMidiMap[1 + 16] = 57;
	keyToMidiMap[2 + 16] = 58;
	keyToMidiMap[3 + 16] = 59;
	keyToMidiMap[4 + 16] = 60;
	keyToMidiMap[5 + 16] = 61;
	keyToMidiMap[6 + 16] = 62;
	keyToMidiMap[7 + 16] = 63;
 
	keyToMidiMap[24] = 72;
	keyToMidiMap[1 + 24] = 65;
	keyToMidiMap[2 + 24] = 66;
	keyToMidiMap[3 + 24] = 67;
	keyToMidiMap[4 + 24] = 68;
	keyToMidiMap[5 + 24] = 69;
	keyToMidiMap[6 + 24] = 70;
	keyToMidiMap[7 + 24] = 71;
 
	// setup pins output/input mode
	pinMode(data, OUTPUT);
	pinMode(clock, OUTPUT);
	pinMode(latch, OUTPUT);
 
	pinMode(rowPin[0], INPUT);
	pinMode(rowPin[1], INPUT);
	pinMode(rowPin[2], INPUT);
	pinMode(rowPin[3], INPUT);
 
        Serial.begin(31250);
 
	delay(1000);
 
}
 
void loop() {
        
      currentMillis = millis();
    
      getNote();
  
      sendChannelExpression();
 
      sendChannelNotes();
}
	
void sendChannelExpression() {
	for (int c = 0; c < 4; c++) {
		if (currentMillis - previousMillisChannel[c] > expressionDelay) {
			midiChannelExpression(c, fsrValue[c]);
		}
	}
}
 
 
void readChannelPressure(int channel) {
	int sensor = analogRead(fsrPin[channel]);
 
	if (sensor > 0) {
		fsrValue[channel] = map(sensor, 0, 900, 10, 127); //log(sensor2)*30+abs(sensor2);
	}
}
 
void sendChannelNotes() {
	for (int i = 0; i < 4; i++) {
 
		readChannelPressure(i);
 
		if (notesChannel[i] > 0	&& (currentMillis > previousMillisChannel[i])) {
			for (int t = 0; t < notesChannel[i]; t++) {
				if (keyPressed[noteChannelPressed[i][t]] == true)
					noteOn(i, keyToMidiMap[noteChannelPressed[i][t]], fsrValue[i]);
			}
			notesChannel[i] = 0;
 
		}
	}
}
 
void getNote() {
 
	for (int i = 0; i < 8; i++) {
 
		scanColumn(bits[i]);
 
		for (int t = 0; t < 4; t++) {
 
			int groupValue = digitalRead(rowPin[t]);
 
                        // key pressed
			if (groupValue != 0 && !keyPressed[8 * t + i]) {
 
				keyPressed[8 * t + i] = true;
 
				// put the note into buffer
 
				previousMillisChannel[t] = currentMillis;
 
				noteChannelPressed[t][notesChannel[t]] = 8 * t + i;
				notesChannel[t]++;
			}
 
			// key released
 
			if (groupValue == 0 && keyPressed[8 * t + i]) {
 
				keyPressed[8 * t + i] = false;
				noteOn(t, keyToMidiMap[8 * t + i], 0);
			}
		}
 
	}
}
 
 
void noteOn(int channel, int pitch, int velocity) {
  	command(0x90 + channel, pitch, velocity);
}
 
 
void midiChannelExpression(int channel, int value) {
  	// Modulation wheel effect
	command(0xB0 + channel, 0x01, value);
}
 
void command(int cmd, int value1, int value2) {
	Serial.write(cmd);
	Serial.write(value1);
	Serial.write(value2);
}

Quelli sono slider resistivi abbastanza costosi.

Un vero Maker DIY userebbe degli slider a corsa corta (2CM) insieme a questi cosi:

BaBBuino: Quelli sono slider resistivi abbastanza costosi.

No, sono sensori di pressione

Il sistema piu usato nei "vecchi" sintetizzatori era il tempo di apertura ... mi spiego: ogni tasto era collegato ad una "molla" argentata che faceva da contatto mobile, quando il tasto era a riposo, la molla toccava una barretta superiore di massa (in comune), mentre quando era premuto toccava una barretta inferiore collegata al positivo (anche questa in comune) ... dato che fra le due barrette c'erano circa 7mm di spazio e la "molla" aveva un diametro di 3, fra il momento in cui lasciava la barretta superiore e quello in cui toccava quella inferiore c'era sempre un certo tempo in cui non era connessa a nulla ... il circuito rilevava il distaco dalla barretta superiore come "premuto", ed inoltre misurava il tempo in cui non era connessa, finche' toccava la barretta inferiore, e dato che piu velocemente "pesti" :P sul tasto, maggiore e' la sua velocita', e quindi minore e' il tempo in cui il circuito resta aperto, questo tempo veniva usato per calcolarci la "forza" con cui avevi premuto il tasto, e simulare la funzione di "velocity" ... ottimo e robusto, usato soprattutto per "simulatori" di pianoforte professionali, ma meccanicamente non semplice da implementare (i primi pianoforte elettronici costavano parecchio, anche per questo motivo :P), ed inoltre serve un'ingresso che rilevi anche la condizione intermedia, quindi non facile usando semplici ingressi digitali (all'epoca erano analogici :P)

In un sistema vecchissimo che mi era capitato in mano, addirittura, usavano lampadine, fotocellule e "diaframmi" di lamierino annerito con delle incisioni progressivamente piu larghe, ma questa e' preistoria dei sintetizzatori analogici, e sarebbe tutto tranne che pratico, persino usando dei led al posto delle lampadine (che anche se erano sottoalimentate, ogni tanto si bruciavano :P XD)

In altri sistemi piu nuovi, c'erano delle tastiere fatte con "tasti" disegnati con inchiostro conduttivo (tipo i contatti delle tastiere per PC di adesso, solo a forma di tasti), con sotto dei "pad" piezoelettrici rettangolari che facevano una doppia funzione ... il contatto superiore dava il "premuto", ed il pad piezoelettrico inferiore dava la "forza" con cui avevi premuto il tasto ... complicati, fragili ed un'incubo a gestirli ...

Molto interessante c'è davvero da imparare parlando con gente come voi :')

Quindi, posso avere 2 opzioni o usare i sensori di pressione, o i micro switch. Da quello che ho capito, in poche parole sono dei potenziometri no?

Ecco, volevo sapere quale sarebbe il prezzo, delle due componenti, anche perché nel piano che mi serve devo avere almeno 5 ottave, cioè 40 tasti :3

Un'altra domanda, avete presente quei sensori che si trovano all'interno di un telecomando? cioè quelli per premere i bottoni. Sono anche sensori di pressione? oppure servono solo a fare contatto? Scusate se mi esprimo in maniera così superficiale, ma non conosco i termini di questo settore.

Eccone uno: 26e su ebay, moltiplicato per 40 fa... tanto! :D

http://www.ebay.it/itm/Sensore-di-pressione-15mm-/251380463345?pt=Componenti_elettronici_attivi&hash=item3a877176f1

Dimenticavo: probabilmente il feeling di questi "tasti", per chi è abituato a suonare, dev'essere tragico.

BaBBuino hai sicuramente ragione, difatti ho anche un pianoforte acustico. e la cosa è molto diversa. Ma purtroppo tramite il piano acustico non posso comunicare con il pc, e poiché lo uso per lavoro è essenziale per me.

Allora, escludiamo i sensori di pressione.

I microswitch dovrebbero funzionare allo stesso modo no? potrei usare quelli anche perché il prezzo è più ragionevole. Quindi per rendere l' effetto più realistico, uso delle molle che rallenteranno la discesa del tasto.

A questo punto, devo tramite Arduino, collegare la tastiera creata al pc, tramite il cavo midi con uscita usb. (cosa che non so fare)

Adesso dovrebbe teoricamente funzionare. Cioè, alla fine, capisco che non sarà lo stesso che suonare un pianoforte, ma più o meno dovremmo essere lì. Il vst che uso è il pianoteq4.

Importante: mi piacerebbe che ogni tasto fosse autonomo.

Avvisatemi se sbaglio, così mi munisco del materiale ed inizio : ), ovviamente inizierò con un tasto.

Grazie ancora per la pazienza

Se usi dei microswitch, e vuoi ANCHE il velocity, te ne servono 2 per tasto (inizio corsa e fine corsa del tasto ... 80 micro sono tantini da gestire ...

Poi devi trovarli silenziosi (sentirsi una marea di clikclikclikclikclik ogni volta che si suona non sembra molto "professionale", per non parlare del fastidio ... magari usando tasti in gomma (come quelli dei telecomandi) risolveresti in parte la cosa, ma resterebbe sempre il lato meccanico, oltre alla gestione di una marea di switch ...

Ups! questo mi complica di non poco le cose :') .

Anche se l'effetto non verrà uguale a quello sperato, potrei creare un pedale soltanto dove con la pressione che metterò, gestirà il velocity.

Anche se non potrò controllarlo in ogni singolo tasto, vedrò di accontentarmi :)

Si può fare?

Etemenanki: Se usi dei microswitch, e vuoi ANCHE il velocity, te ne servono 2 per tasto (inizio corsa e fine corsa del tasto ... 80 micro sono tantini da gestire ...

Poi devi trovarli silenziosi (sentirsi una marea di clikclikclikclikclik ogni volta che si suona non sembra molto "professionale", per non parlare del fastidio ... magari usando tasti in gomma (come quelli dei telecomandi) risolveresti in parte la cosa, ma resterebbe sempre il lato meccanico, oltre alla gestione di una marea di switch ...

Infatti...

Ci si può procurare una vera tastiera, con contatti elettrici, recuperata da qualche strumento rotto. Sarebbe la soluzione migliore.

Eventualmente, per l'intensità sonora, ci si potrebbe dotare di un potenziometro a pedaliera, modulato con un piede. Con un pò di pratica si potrebbero raggiungere risultati soddisfacenti, ed il feeling con i tasti sarebbe salvo.

BaBBuino: Infatti...

Ci si può procurare una vera tastiera, con contatti elettrici, recuperata da qualche strumento rotto. Sarebbe la soluzione migliore.

Eventualmente, per l'intensità sonora, ci si potrebbe dotare di un potenziometro a pedaliera, modulato con un piede. Con un pò di pratica si potrebbero raggiungere risultati soddisfacenti, ed il feeling con i tasti sarebbe salvo.

Esatto! a questo punto scelgo questa soluzione più semplice.

  • Un pedale lo ho, ed quello che uso per il sustain nella tastiera, ma per l'occasione posso usarlo per questo obiettivo.
  • Dopo devo collegarlo al pc tramite cavo midi? perché il pedale in uscita ha un jack
  • Quindi devo assegnare il valore al pedale, cioè, quando applicherò la pressione sarà es: al valore 10 senza a 0.
  • E in fine devo far si che il tutto sia sincronizzato con la tastiera.

Giusto? ho le idee poco chiare :')

1) Recuperare una tastiera usata da cannibalizzare la sola parte meccanica (devono essere tasti elettrici) 2) Procurarsi una Arduino MEGA. La UNO non ha sufficienti ingressi per gestire 40 tasti. E' necessario usare la tecnica "a matrice". 3) Procurarsi un potenziometro a pedale (non un interruttore ON-OFF) per il volume della nota. 4) Fare un bello Sketch... 5) Ringraziare gli amici del Forum e spedire loro un vaglia postale da 20e

BaBBuino: 1) Recuperare una tastiera usata da cannibalizzare la sola parte meccanica (devono essere tasti elettrici) 2) Procurarsi una Arduino MEGA. La UNO non ha sufficienti ingressi per gestire 40 tasti. E' necessario usare la tecnica "a matrice". 3) Procurarsi un potenziometro a pedale (non un interruttore ON-OFF) per il volume della nota. 4) Fare un bello Sketch... 5) Ringraziare gli amici del Forum e spedire loro un vaglia postale da 20e

Ahahahaha :stuck_out_tongue_closed_eyes:

Allora ricapitoliamo, che come ho detto, sono una frana in quest'ambito. La tastiera c'è, anche se è vecchia di 10 anni, usa tasti elettrici. Ora la domanda è: devo per forza collegare ogni singolo tasto? o posso collegare una sola scheda dove sono collegati tutti i tasti? Come potenziometro a pedale uso quello che ho già, però non è usb, devo adeguarlo.

La tastiera che hai, di che tipo e' ? ... come sono i contatti ? ... molle e barrette, lamine, stampato con cupoline in gomma conduttiva, altro ? ... qualche immagine dei contatti ?

Ciao, scusa per la risposta in ritardo, ma ho avuto poco tempo. Comunque, ho cercato in altri siti di elettronica, e mi hanno detto che era meglio toglierci mano, e quindi comprarmi una tastiera che avesse l'opzione che cercavo. Mi hanno consigliato di comprare una masterkeyboard, l'idea non è male, ma 1° mi piacerebbe completare questo progetto con i miei sforzi, e mi servirà ad apprendere qualcosa, che in futuro potrebbe servirmi. 2° non cerco la perfezione, mi accontento anche di un progetto arrangiato, e quindi mi sembra inutile spendere molti soldi per uno strumento digitale che userò poco. Di solito registro con il mio pianoforte acustico, ora mi sono deciso a provare il digitale, ma senza la funzione sensitive velocity, nonci sento gusto nel suonare. Completiamo rispondendo alla domanda: La mia tastiera è una yamaha ypt-210, e non è sensibile alla velocità. La tastiera all'interno si presenta con un circuito stampato e bottoni fatti in gomma 'cupoline'.

ypt-210, che attualmente collegata ad un pc.

Purtroppo su quelle a stampato, non ci si puo fare molto ... l'unica possibilita' sarebbe di aggiungere un contatto che si apre nel primo millimetro di corsa, per poterlo usare come "start", ma ti toccherebbe aggiungerne uno per tasto, e viene un casino pazzesco a livello di meccanica ...

Mi torna in mente che, secoli fa', NE vendeva un kit per sint che aveva una tastiera con contatti a barre e molle, bisognerebbe vedere se si trova ancora qualcosa del genere in qualche vecchia fiera dell'elettronica (a volte ne vedo di vendute come ricambi, ma e' dura ... ) ... oppure trovarne una scassata da qualche negozio di strumenti musicali e "cannibalizzarla" (ma assicurandosi prima che sia del tipo con molle e barre o con doppi contatti NA+NC, per il velocity)

Ho una vecchia tastiera della GEM, però appunto mi rimangono solo le tastiere, e sempre su stampato però ha anche le molle. Anche se non saprei come collegarla al pc e farle funzionare..

Comunque sia non si può fare l'automazione? cioè spostare l'onda velocity con un potenziometro o tasto o un pedale?