|
|
| Riga 1: |
Riga 1: |
| − | ====Introduzione==== | + | ===[[Ricezione dei dati Midi senza le funzioni di Alsa]]=== |
| − | Per mera curiosità, e sempre a fini didattici presentiamo qui una soluzioni alternativa per ricevere da un dispositivo esterno Midi (ad esempio una tastiera Midi) i messaggi MIDI <SPAN style="text-decoration:underline">senza</span> l'utilizzo delle funzioni esterne di ALSA.
| |
| − | | |
| − | | |
| − | | |
| − | ===Ricezione mediante la lettura del file-device con ''Open''===
| |
| − | Dopo aver collegato la tastiera Midi al computer, intendiamo operare sul ''file-device'' provvisoriamente creato dal sistema e corrispondente alla predetta tastiera. Con la parola chiave ''Watch'', dopo aver aperto con la funzione ''OPEN'' il file-device, faremo si che il programma resti in attesa di un messaggio Midi in arrivo dalla tastiera medesima.
| |
| − | <P>Il file-device temporaneo, che rappresenta virtualmente la porta della nostra tastiera Midi periferica, si chiama solitamente: ''midiC2D0'' |[[#Note|1]]| |[[#Note|2]]|, e si trova nel seguente percorso: ''/dev/snd/midiC2D0''. All'atto della creazione di tale file-device viene creato un corrispettivo file-device, chiamato ''midi2'', all'interno della directory ''/dev'' , e ugualmente utile per la ricezione dei dati Midi grezzi provenienti dal dispositivo Midi esterno. Quindi, più precisamente, detto file-device sarà creato nel percorso: ''/dev/midi2'' .</p>
| |
| − | <p>Se potrà essere letto almeno un byte dal file-device, allora verrà chiamato l'evento ''File_Read()''.</p>
| |
| − | | |
| − | varFile As File
| |
| − |
| |
| − | '''Public''' Sub Form_Open()
| |
| − |
| |
| − | varFile = Open "/dev/snd/midiC2D0" For Read Watch
| |
| − |
| |
| − | '''End'''
| |
| − |
| |
| − |
| |
| − | '''Public''' Sub File_Read()
| |
| − |
| |
| − | Dim dato As Byte
| |
| − |
| |
| − | ''<Font Color= #006400>' Leggiamo il file-device e scriviamo il valore ottenuto nella variabile "dato".</font>
| |
| − | Read #varFile, dato ' |[[#Note|3]]|
| |
| − |
| |
| − |
| |
| − | <Font Color= #006400>' ''Poiché può accadere che la tastiera Midi invii in continuazione il messaggio Midi 254 (Active Sensing) ed altri messaggi''
| |
| − | ''che a noi qui non interessano, li escludiamo con un filtro:</font>''
| |
| − | If by > 239 Then Return
| |
| − |
| |
| − | <Font Color= #006400>' ''Per fini didattici ci limitiamo qui solo a scrivere il dato in console per vederlo.</font>
| |
| − | Print "byte inviato dalla tastiera = "; dato
| |
| − |
| |
| − | '''End'''
| |
| − | | |
| − | <BR>Come si può notare, la ricezione dei dati dalla tastiera Midi esterna è avvenuta <Span style="text-decoration:underline">senza</span> l'utilizzo di alcuna funzione ALSA, ma direttamente andando a "raccoglierli" dal file-device della porta virtuale della tastiera.
| |
| − | | |
| − | <BR>Si fa presente, ad ogni modo, che tale soluzione ''non'' è proprio ottimale per almeno le tre seguenti ragioni:
| |
| − | * si va in ambiente ''extra ALSA'', laddove invece si intendeva programmare utilizzando le API di ALSA;
| |
| − | * ALSA non riesce ad intercettare più i dati provenienti dalla tastiera esterna Midi, essendo stati intercettati da noi con la presente modalità ''extra ALSA'';
| |
| − | * la presente soluzione ''extra ALSA'' <Span style="text-decoration:underline">potrebbe</span> interferire o comunque creare problemi alle funzionalità del sistema ALSA. Attualmente non si è a conoscenza di tutti i possibili disturbi.
| |
| − | <BR>Possiamo riportare, però, il caso di contemporaneo tentativo di ricezione dei dati da un medesimo dispositivo hardware Midi esterno con funzioni ALSA e con il presente metodo ''extra'' ALSA. Ebbene è stato accertato che in tale caso soltanto una delle procedure intercetterà i dati provenienti dal dispositivo Midi esterno. Se, ad esempio, verrà avviato prima il metodo ''extra'' ALSA e successivamente quello mediante le funzioni ALSA di ricezione (magari anche con due applicativi distinti), facendoli comunque funzionare ''contemporaneamente'', l'applicativo che utilizza le funzioni di ALSA per ricevere i dati Midi, segnalerà in console il seguente errore:
| |
| − | <BR>"''Subscribe inport: err=-11 (Resource temporarily unavailable)''".
| |
| − | | |
| − | | |
| − | ====Ricezione dati da ''più'' dispositivi Midi esterni====
| |
| − | | |
| − | Sino ad ora abbiamo considerato l'invio di messaggi Midi da <Span style="text-decoration:underline">un solo</span> dispositivo esterno, per esempio una sola tastiera Midi. Come fare, però, se volessimo, con la modalità che stiamo ora trattando, ricevere e gestire i dati da <Span style="text-decoration:underline">più</span> tastiere Midi esterne ?
| |
| − | <BR>Dobbiamo premettere che se colleghiamo al computer via USB un secondo dispositivo Midi esterno, possiamo notare che in ''/dev/snd'' comparirà un altro file-device simile a quello che creato dal sistema quando avevamo collegato la prima tastiera Midi esterna. Questa volta il nuovo file-device, che si riferisce alla <Span style="text-decoration:underline">seconda</span> tastiera, avrà come nome: ''midiC3D0''. Qualora collegassimo un terzo dispositivo Midi estreno, avremmo un ulteriore file-device "''midiC4D0''", e così via. Anche in tal caso verrà creato un corrispondente file-device, ugualmente utilizzabile, nella directory ''/dev''. Avremo quindi: ''/dev/midi3'', ''/dev/midi4'', etc.
| |
| − | <BR>A questo punto, però, se proviamo ad inserire due o più ''OPEN.... Watch'', ciascuno per ogni file-device creato e relativo ad un dispositivo Midi esterno, non potremmo intercettare i dati provenienti dalla seconda (o eventualmente anche da una terza tastiera) collegata; sia perché saremmo costretti a prevedere ''una'' sola subroutine '' File_Read()'', sia perché - pur inserendo in detta sub-routine un ''Read'' per lo stream proveniente da ciascun file-device, riusciremmo ad intercettare <Span style="text-decoration:underline">soltanto</span> i dati del primo file-device.
| |
| − | | |
| − | <P>Dobbiamo allora trovare un'altra strategia: usare la funzione ''Exec'' per lanciare due sotto-programmi Gambas autonomi, resi ''demoni'' (quindi invisibili), con i quali gestire i dati, intercettati da ciascun file-device (opportunamente aperto in ''Watch'') delle tastiere collegate, inviando i medesimi allo standard output del sistema. Il programma principale si preoccuperà, pertanto, solo di intercettare dallo standard output del sistema i dati provenienti da ciascun <Span style="text-decoration:underline">distinto</span> sotto-programma</p>
| |
| − | <P>Scriveremo allora i due piccoli sotto-programmi in questo modo:</p>
| |
| − | | |
| − | ''<Font Color= #006400>' Gambas-3 class file''</font>
| |
| − | ''<Font Color= #006400>' '''Primo''' sotto-programma''</font>
| |
| − |
| |
| − |
| |
| − | primo As File
| |
| − | out As Stream
| |
| − |
| |
| − |
| |
| − | '''PUBLIC''' Sub Form_Open()
| |
| − |
| |
| − | ''<Font Color= #006400>' rendiamo "demone" il sotto-programma:''</font>
| |
| − | Application.Daemon = True
| |
| − |
| |
| − | ''<Font Color= #006400>' Apre lo standard output del sistema per la scrittura.''</font>
| |
| − | out = Open "/dev/stdout" For Write
| |
| − |
| |
| − | ''<Font Color= #006400>' Apre lo il file-device della prima tastiera esterna collegata e resta in attesa.''</font>
| |
| − | primo = Open "/dev/snd/midiC'''2'''D0" For Watch
| |
| − |
| |
| − | '''END'''
| |
| − |
| |
| − |
| |
| − | '''PUBLIC''' Sub File_read() ''<Font Color= #006400>' Se potrà essere letto almeno un byte dal file-device, verrà scatenata questa subroutine.''</font>
| |
| − |
| |
| − | Dim by As Byte
| |
| − |
| |
| − | ''<Font Color= #006400>' Legge i dati intercettati dal file-device che rappresenta la porta virtuale della prima tastiera esterna collegata.''</font>
| |
| − | Read #primo, by
| |
| − |
| |
| − | ''<Font Color= #006400>' Filtra i byte "''Sensing Active''" e degli altri eventi qui non necessari.''</font>
| |
| − | If by > 239 Then
| |
| − | Return
| |
| − | Endif
| |
| − |
| |
| − | ''<Font Color= #006400>' Scrive quei dati nello standard output del sistema.''</font>
| |
| − | Write #out, by As Byte
| |
| − |
| |
| − | '''END'''
| |
| − | | |
| − | <P>Salvato il codice sopra descritto come primo sotto-programma a se stante (lo chiameremo per esempio: "primo_sotto"), scriviamo ora il codice del secondo sotto-programma per la ricezione dei dati provenienti dal secondo dispositivo Midi esterno:</p>
| |
| − | | |
| − | ''<Font Color= #006400>' Gambas-3 class file''</font>
| |
| − | ''<Font Color= #006400>' '''Secondo''' sotto-programma''</font>
| |
| − |
| |
| − |
| |
| − | secondo As File
| |
| − | out As Stream
| |
| − |
| |
| − |
| |
| − | '''PUBLIC''' Sub Form_Open()
| |
| − |
| |
| − | ''<Font Color= #006400>' rendiamo "demone" il sotto-programma:''</font>
| |
| − | Application.Daemon = True
| |
| − |
| |
| − | ''<Font Color= #006400>' Apre lo standard output del sistema per la scrittura.''</font>
| |
| − | out = Open "/dev/stdout" For Write
| |
| − |
| |
| − | ''<Font Color= #006400>' Apre lo il file-device della seconda tastiera esterna collegata e resta in attesa.''</font>
| |
| − | secondo = Open "/dev/snd/midiC'''3'''D0" For Watch
| |
| − |
| |
| − | '''END'''
| |
| − |
| |
| − |
| |
| − | '''PUBLIC''' Sub File_read() ''<Font Color= #006400>' Se potrà essere letto almeno un byte dal file-device, verrà scatenata questa subroutine.''</font>
| |
| − |
| |
| − | Dim by As Byte
| |
| − |
| |
| − | ''<Font Color= #006400>' Legge i dati intercettati dal file-device che rappresenta la porta virtuale della seconda tastiera esterna collegata.''</font>
| |
| − | Read #secondo, by
| |
| − |
| |
| − | ''<Font Color= #006400>' Filtra i byte "''Sensing Active''" e degli altri eventi qui non necessari.''</font>
| |
| − | If by > 239 Then
| |
| − | Return
| |
| − | Endif
| |
| − |
| |
| − | ''<Font Color= #006400>' Scrive quei dati nello standard output del sistema.''</font>
| |
| − | Write #out, by As Byte
| |
| − |
| |
| − | '''END'''
| |
| − | | |
| − | <P>Proceduto a salvare con il nome "secondo_sotto" anche questo secondo sotto-programma autonomo, scriviamo il codice del programma principale, che avrà il compito, come già detto, di intercettare a sua volta i dati inviati dai due sotto-programmi allo standar output del sistema:</p>
| |
| − | | |
| − | ''<Font Color= #006400>' Gambas-3 class file''</font>
| |
| − | ''<Font Color= #006400>' Programma '''principale'''''</font>
| |
| − |
| |
| − |
| |
| − | prm as process
| |
| − | scnd as process
| |
| − |
| |
| − |
| |
| − | '''PUBLIC''' Sub Form_Open()
| |
| − |
| |
| − | ''<Font Color= #006400>' Avvia come processo il primo ed il secondo sotto-programma''</font>
| |
| − | ''<Font Color= #006400>' che abbiamo salvato, per esempio, nella Home.''</font>
| |
| − | prm = Exec ["percorso/primo_sotto.gambas"] For Read As "primo"
| |
| − |
| |
| − | scnd = Exec ["percorso/secondo_sotto.gambas"] For Read As "secondo"
| |
| − |
| |
| − | '''END'''
| |
| − |
| |
| − |
| |
| − | '''PUBLIC''' Sub primo_read() ''<Font Color= #006400>' Se potrà essere almeno un byte dallo standard output del processo "primo", verrà sollevata questa subroutine.''</font>
| |
| − |
| |
| − | Dim by As Byte
| |
| − |
| |
| − | ''<Font Color= #006400>' Legge i dati scritti dal programma ''primo_sotto''.''</font>
| |
| − | Read #prm, by
| |
| − |
| |
| − | ''<Font Color= #006400>' Qui per soli fini didattici semplicemente scriviamo in console i dati intercettati.''</font>
| |
| − | Print by
| |
| − |
| |
| − | '''END'''
| |
| − |
| |
| − |
| |
| − | '''PUBLIC''' Sub secondo_read() ''<Font Color= #006400>' Se potrà essere almeno un byte dallo standard output del processo "secondo", verrà sollevata questa subroutine.''</font>
| |
| − |
| |
| − | Dim by As Byte
| |
| − |
| |
| − | ''<Font Color= #006400>' Legge i dati scritti dal programma ''secondo_sotto''.''</font>
| |
| − | Read #scnd, by
| |
| − |
| |
| − | ''<Font Color= #006400>' Qui per soli fini didattici semplicemente scriviamo in console i dati intercettati.''</font>
| |
| − | Print by
| |
| − |
| |
| − | '''END'''
| |
| − |
| |
| − |
| |
| − | '''PUBLIC''' Sub Button1_Click() ''<Font Color= #006400>' Per chiudere regolarmente i sotto-programmi ed il programma principale''</font>
| |
| − |
| |
| − | prm.kill()
| |
| − | scnd.kill()
| |
| − | Me.close()
| |
| − |
| |
| − | '''END'''
| |
| − | | |
| − | | |
| − | ----
| |
| − | | |
| − | | |
| − | ===Ricezione mediante ''Process''=== | |
| − | | |
| − | E' possibile in alternativa ricevere i dati dal file-device utilizzando non ''Open'', ma ''Process''.
| |
| − | | |
| − | varProc As Process
| |
| − |
| |
| − | '''Public''' Sub ToggleButton1_Click()
| |
| − |
| |
| − | If Last.value Then
| |
| − |
| |
| − | varProc = Exec ["cat", "/dev/snd/midiC2D0"] For Read As "varproc"
| |
| − |
| |
| − | ' ''<Font Color= #006400>oppure:''
| |
| − | ' ''varProc = Shell "cat /dev/snd/midiC2D0" For Read As "varproc"''</font>
| |
| − |
| |
| − | Else
| |
| − | ' ''<Font Color= #006400>cliccando di nuovo sul tasto, il flusso è bloccato,''
| |
| − | ' ''ma cliccandoci ancora il processo sarà riattivato:''</font>
| |
| − | varProc.Kill
| |
| − |
| |
| − | Endif
| |
| − |
| |
| − | '''End'''
| |
| − |
| |
| − |
| |
| − | '''Public''' Sub varproc_Read()
| |
| − |
| |
| − | Dim dato As Byte
| |
| − |
| |
| − | ' ''<Font Color= #006400>Leggiamo il file-device e scriviamo il valore ottenuto nella variabile "dato".</font>
| |
| − | Read #varProc, dato ' |[[#Note|3]]|
| |
| − |
| |
| − |
| |
| − | <Font Color=#006400>' ''Poiché la tastiera Midi invia in continuazione il messaggio Midi 254 (Active Sensing) ed altri messaggi che a noi qui non interessano, li escludiamo.</font>''
| |
| − | If by < 240 Then
| |
| − | <Font Color=#006400>' ''Per fini didattici ci limitiamo qui solo a scrivere il dato in console per vederlo.</font>
| |
| − | Print "byte inviato dalla tastiera = "; dato
| |
| − | Endif
| |
| − |
| |
| − | '''End'''
| |
| − | | |
| − | | |
| − | ----
| |
| − | | |
| − | | |
| − | ===Ricezione mediante ''Pipe''===
| |
| − | | |
| − | E' possibile anche utilizzare il comando "''Pipe''". Tutto resta come con ''Open''.
| |
| − | | |
| − | varFile As File
| |
| − |
| |
| − | '''Public''' Sub Form_Open()
| |
| − |
| |
| − | varFile = <Font Color=#B22222>Pipe</font> "/dev/snd/midiC2D0" For Read Watch
| |
| − |
| |
| − | '''End'''
| |
| − |
| |
| − |
| |
| − | '''Public''' Sub File_Read() ' |[[#Note|4]]|
| |
| − |
| |
| − | Dim dato As Byte
| |
| − |
| |
| − | Read #varFile, dato ' |[[#Note|3]]|
| |
| − |
| |
| − | If by < 240 Then
| |
| − | Print "byte inviato dalla tastiera = "; dato
| |
| − | Endif
| |
| − |
| |
| − | '''End'''
| |
| − | | |
| − | | |
| − | ----
| |
| − | | |
| − | | |
| − | ===Ricezione mediante ''Object.Attach''===
| |
| − | Potremo anche usare il metodo ''Object.Attach'' per gestire l'evento della ricezione dei dati Midi, associando l'oggetto file alla definizione dell'evento.
| |
| − | | |
| − | varFile As File
| |
| − |
| |
| − |
| |
| − | '''Public''' Sub Form_Open()
| |
| − |
| |
| − | varFile = Open "/dev/snd/midiC2D0" For Read Watch
| |
| − |
| |
| − | Object.Attach(fdMid, FMain, "eventoMidi")
| |
| − |
| |
| − | '''End'''
| |
| − |
| |
| − |
| |
| − | '''Public''' Sub eventoMidi_Read()
| |
| − |
| |
| − | Dim b As Byte
| |
| − |
| |
| − | Read #varFile, b
| |
| − | <Font Color=#006400>' ''...il solito filtro:''</font>
| |
| − | If b > 239 Then Return
| |
| − | <Font Color=#006400>' ''Per fini didattici ci limitiamo qui solo a scrivere il dato in console per vederlo:''</font>
| |
| − | Print b
| |
| − |
| |
| − | '''End'''
| |
| − | | |
| − | | |
| − | ====Ricezione dei dati da più dispositivi Midi esterni====
| |
| − | Con il metodo ''Object.Attach'' potremo agevolmente ricevere e gestire i dati Midi, provenienti da due o più tastiere esterne.
| |
| − | | |
| − | | |
| − | varFile1 As File
| |
| − | varFile2 As File
| |
| − |
| |
| − |
| |
| − | '''Public''' Sub Form_Open()
| |
| − |
| |
| − | varFile1 = Open "/dev/snd/midiC2D0" For Read Watch
| |
| − | <Font Color=#006400>' ''Viene associato l'oggetto ''File'' alla denominazione del proprio evento:''</font>
| |
| − | Object.Attach(varFile1, FMain, "eventoMidi1")
| |
| − |
| |
| − |
| |
| − | varFile2 = Open "/dev/snd/midiC3D0" For Read Watch
| |
| − | <Font Color=#006400>' ''Viene associato l'oggetto ''File'' alla denominazione del proprio evento:''</font>
| |
| − | Object.Attach(varFile2, FMain, "eventoMidi2")
| |
| − |
| |
| − | '''End'''
| |
| − |
| |
| − |
| |
| − | <Font Color=#006400>' ''Vengono intercettati i dati provenienti dalla prima tastiera esterna:''</font>
| |
| − | '''Public''' Sub eventoMidi1_Read()
| |
| − |
| |
| − | Dim b1 As Byte
| |
| − |
| |
| − | Read #varFile, b1
| |
| − | <Font Color=#006400>' ''...il solito filtro:</font>
| |
| − | If b1 > 239 Then Return
| |
| − | <Font Color=#006400>' ''Per fini didattici ci limitiamo qui solo a scrivere il dato in console per vederlo:</font>
| |
| − | Print b1
| |
| − |
| |
| − | '''End'''
| |
| − |
| |
| − |
| |
| − | <Font Color=#006400>' ''Vengono intercettati i dati provenienti dalla seconda tastiera esterna:''</font>
| |
| − | '''Public''' Sub eventoMidi2_Read()
| |
| − |
| |
| − | Dim b2 As Byte
| |
| − |
| |
| − | Read #varFile2, b2
| |
| − | <Font Color=#006400>' ''...il solito filtro:</font>
| |
| − | If b2 > 239 Then Return
| |
| − | <Font Color=#006400>' ''Per fini didattici ci limitiamo qui solo a scrivere il dato in console per vederlo:</font>
| |
| − | Print b2
| |
| − |
| |
| − | '''End'''
| |
| − | | |
| − | | |
| − | ----
| |
| − | | |
| − | | |
| − | ===Ricezione mediante ''Observer''===
| |
| − | Potremo anche usare il metodo ''Observer'' per gestire l'evento della ricezione dei dati Midi.
| |
| − | | |
| − | varFile As File
| |
| − |
| |
| − |
| |
| − | '''Public''' Sub Form_Open()
| |
| − |
| |
| − | Dim oss As Observer
| |
| − |
| |
| − | varFile = Open "/dev/snd/midiC2D0" For Read Watch
| |
| − |
| |
| − | oss = New Observer(varFile) As "eventoMidi"
| |
| − |
| |
| − | '''End'''
| |
| − |
| |
| − |
| |
| − | '''Public''' Sub eventoMidi_Read()
| |
| − |
| |
| − | Dim b As Byte
| |
| − |
| |
| − | Read #varFile, b
| |
| − | <Font Color=#006400>' ''...il solito filtro:</font>
| |
| − | If b > 239 Then Return
| |
| − | <Font Color=#006400>' ''Per fini didattici ci limitiamo qui solo a scrivere il dato in console per vederlo:</font>
| |
| − | Print b
| |
| − |
| |
| − | '''End'''
| |
| − | | |
| − | | |
| − | ====Ricezione dei dati da più dispositivi Midi esterni====
| |
| − | Ugualmente, con ''Observer'' potremo ricevere e gestire i dati Midi, provenienti da due o più tastiere esterne.
| |
| − | | |
| − | | |
| − | varFile1 As File
| |
| − | varFile2 As File
| |
| − |
| |
| − |
| |
| − | '''Public''' Sub Form_Open()
| |
| − |
| |
| − | Dim oss1 As Observer
| |
| − | Dim oss2 As Observer
| |
| − |
| |
| − | varFile1 = Open "/dev/snd/midiC2D0" For Read Watch
| |
| − | <Font Color=#006400>' ''Viene "osservato" l'oggetto ''File'' per l'evento:''</font>
| |
| − | oss1 = New Observer(varFile) As "eventoMidi"Object.Attach(varFile1, FMain, "eventoMidi1")
| |
| − |
| |
| − |
| |
| − | varFile2 = Open "/dev/snd/midiC3D0" For Read Watch
| |
| − | <Font Color=#006400>' ''Viene "osservato" l'oggetto ''File'' per l'evento:''</font>
| |
| − | oss2 = New Observer(varFile) As "eventoMidi"Object.Attach(varFile2, FMain, "eventoMidi2")
| |
| − |
| |
| − | '''End'''
| |
| − |
| |
| − |
| |
| − | <Font Color=#006400>' ''Vengono intercettati i dati provenienti dalla prima tastiera esterna:''</font>
| |
| − | '''Public''' Sub eventoMidi1_Read()
| |
| − |
| |
| − | Dim b1 As Byte
| |
| − |
| |
| − | Read #varFile, b1
| |
| − | <Font Color=#006400>' ''...il solito filtro:</font>
| |
| − | If b1 > 239 Then Return
| |
| − | <Font Color=#006400>' ''Per fini didattici ci limitiamo qui solo a scrivere il dato in console per vederlo:</font>
| |
| − | Print b1
| |
| − |
| |
| − | '''End'''
| |
| − |
| |
| − |
| |
| − | <Font Color=#006400>' ''Vengono intercettati i dati provenienti dalla seconda tastiera esterna:''</font>
| |
| − | '''Public''' Sub eventoMidi2_Read()
| |
| − |
| |
| − | Dim b2 As Byte
| |
| − |
| |
| − | Read #varFile2, b2
| |
| − | <Font Color=#006400>' ''...il solito filtro:</font>
| |
| − | If b2 > 239 Then Return
| |
| − | <Font Color=#006400>' ''Per fini didattici ci limitiamo qui solo a scrivere il dato in console per vederlo:</font>
| |
| − | Print b2
| |
| − |
| |
| − | '''End'''
| |
| − | | |
| − | | |
| − | ----
| |
| − | | |
| − | | |
| − | ===Ricostruzione ed invio ad ALSA di eventi ricevuti ''extra ALSA'' da una tastiera Midi esterna===
| |
| − | | |
| − | Anche per questa particolare modalità di ricezione ''extra ALSA'' dei messaggi Midi da una tastiera esterna considereremo il procedimento necessario, una volta ottenuti i dati, per costruire l'evento Midi in modo adatto ad essere inviato ad ALSA.
| |
| − | | |
| − | Dovremo tenere conto che sarà ovviamente necessario integrare la parte ''extra ALSA'' (come l'abbiamo vista nei due precedenti paragrafi) di ricezione dei dati con la parte di utilizzo delle funzioni delle API di ALSA per inviargli i dati necessari dell'evento NoteON, così da ottenere il suono finale.
| |
| − | | |
| − | <P>Pertanto porremo nella classe principale una routine di avvio con le dichiarazioni delle variabili e delle costanti, con i primi riferimenti ad ALSA e con la riga per aprire il file-device (midiC2D0) che rappresenta la porta virtuale della tastiera esterna:</p>
| |
| − | | |
| − | | |
| − | ''<Font Color= #006400>' Gambas-3 class file''</font>
| |
| − |
| |
| − |
| |
| − | ''<Font Color= #006400>' impostare queste costanti per suonare''</font>
| |
| − | Const outdevice As Integer = 14 ''<Font Color= #006400>' 14=midi out - ALSA''</font>
| |
| − | Const outport As Integer = 0 ''<Font Color= #006400>' porta d'uscita, solitamente 0''</font>
| |
| − |
| |
| − |
| |
| − | Public alsa As CAlsa ''<Font Color= #006400>' classe che incapsula le funzioni alsa''</font>
| |
| − |
| |
| − | Public varFile As File
| |
| − |
| |
| − | bb[4] As Byte
| |
| − | n As Integer
| |
| − |
| |
| − |
| |
| − | '''Public''' Sub Form_Open()
| |
| − |
| |
| − | ''<Font Color= #006400>' creare ("istanziare") la classe per poterla usare''</font>
| |
| − | alsa = New CAlsa As "alsa"
| |
| − | ''<Font Color= #006400>' aprire alsa e assegnare un nome''</font>
| |
| − | alsa.alsa_open("Gambas drum machine")
| |
| − | ''<Font Color= #006400>' scegliere la periferica su cui suonare''</font>
| |
| − | alsa.setdevice(outdevice, outport)
| |
| − |
| |
| − | ''''''''''
| |
| − |
| |
| − | varFile = Open "/dev/snd/midiC2D0" For Read Watch
| |
| − |
| |
| − | End
| |
| − | | |
| − | <BR>Quindi inseriamo la parte relativa all'invio dei dati Midi alle funzioni della classe CAlsa.class, preposte alla costruzione dell'evento Midi, per il suo successivo invio ad ALSA.
| |
| − | <BR>A fini esemplificativi invieremo semplicemente i dati utili per un evento NoteON.
| |
| − | | |
| − | '''Public''' Sub File_Read()
| |
| − |
| |
| − | Dim by As Byte
| |
| − |
| |
| − | Read #varFile, by
| |
| − |
| |
| − | If by > 253 Then Return ''<Font Color= #006400>' In questo modo eliminiamo il byte 254 (Active Sensing) costantemente inviato dalla tastiera esterna.''</font>
| |
| − |
| |
| − | n += 1
| |
| − |
| |
| − | bb[n] = by
| |
| − |
| |
| − |
| |
| − | ''<Font Color= #006400>' Quando saranno giunti i tre valori costitutivi del NoteON,''</font>
| |
| − | ''<Font Color= #006400>' si passano alla funzione seguente per la costruzione dell'evento Midi.''</font>
| |
| − | If n = 3 Then
| |
| − |
| |
| − | ''<Font Color= #006400>' Questa operazione estrae il valore del canale dal messaggio di Stato inviato dalla tastiera.''</font>
| |
| − | bb[1] = bb[1] AND 15
| |
| − |
| |
| − | ''<Font Color= #006400>' La funzione che segue invia i dati alla funzione alsa.noteon.''</font>
| |
| − | alsa.noteon(bb[1], bb[2], bb[3])
| |
| − | n = 0
| |
| − | Endif
| |
| − |
| |
| − | '''End'''
| |
| − | | |
| − | | |
| − | | |
| − | ==Note==
| |
| − | | |
| − | [1] Si è avuto modo di constatare, però, che facendo partire il sistema operativo con il dispositivo Midi esterno <Span style="text-decoration:underline">già</span> connesso al computer, il nome del file-device è leggermente diverso: ''midiC'''1'''D0''. Pertanto, è opportuno effettuare (magari anche a livello di codice) una verifica del nome esatto del file-device.
| |
| − | | |
| − | [2] Il nome del file-device è del medesimo tipo dei file-device dei dispositivi ''rawmidi'', che controllano flussi di eventi Midi 'nudi' e privi di temporizzazione. Il modello di file-device di questo tipo è: ''midiCcDd'', laddove ''c'' è il numero di canale/card (0-3) e ''d'' sarebbe il numero assegnato al dispositivo (0-16). Dalle prove effettuate con una o più tastiere collegate al computer il parametro ''d'' è comunque risultato essere sempre uguale a zero.
| |
| − | | |
| − | [3] Se non si vuole usare la variabile dichiarata come ''File'', o nell'altro esempio la variabile dichiarata come ''Process'', in alternativa è possibile usare '''#Last''', il quale, come è noto, restituisce un riferimento all'ultimo oggetto chiamato da un evento:
| |
| − | Read #Last, dato
| |
| − | | |
| − | [4] Se si scrive ''Sub Pipe_Read()'', come suggerisce la guida Gambas per intercettare l'evento, sembra non funzionare.
| |
