Masterkeyboard-Simulation

Für den Hobbymusiker hat sich in letzter Zeit auf dem Musikmarkt eine Menge getan. Vor einigen Jahren mußte man, um einigermaßen brauchbare Sounds für sein Heimstudio zusammenzubekommen, noch mehrere tausend Mark investieren. Heute bekommt man schon eine gute Soundpalette in Form von Midiexpandern geliefert, die auch für den mageren Geldbeutel von Schülern und Studenten erschwinglich sind.

Um jedoch die Möglichkeiten eines Midiexpanders voll ausschöpfen zu können, ist ein gutes Masterkeyboard notwendig. Ein solches Masterkeyboard kann jedoch durchaus den Preis eines Expanders übersteigen. Wer bereits ein midifähiges Keyboard oder einen Synthesizer mit Tastatur besitzt, vielleicht noch ein etwas älteres Modell, das gerade die einfachsten Midi-Meldungen sendet, wird kaum einsehen wollen, weshalb er noch eine weitere Tastatur anschaffen soll.

Aber schließlich haben wir ja einen Atari-ST, der mit seinem eingebauten MIDI-Interface sehr musikerfreundlich konstruiert wurde. Warum also nicht die Möglichkeiten eines einfachen Keyboards etwas aufpolieren und einfach den ST zuhilfe nehmen, um sich die Funktionen eines Masterkeyboards selbst zu programmieren?

Zunächst einmal sollte geklärt werden, was ein Masterkeyboard eigentlich alles können sollte. Die meisten Midiexpander verfügen über einen sogenannten Multi-Mode, das heißt, es können mehrere Instrumente gleichzeitig gespielt werden. Ein gutes Masterkeyboard ist in der Lage, jedem Instrument einen bestimmten Bereich auf dem Keyboard zuzuordnen, so daß man beispielsweise mit der linken Hand Gitarre spielen, mit der rechten Hand Saxophon und für einen vollen Sound über die gesamte Tastatur einen Streicherteppich legen kann. Ein Masterkeyboard sollte die Möglichkeit bieten, diese Bereiche frei definieren zu können, so daß sowohl frei wählbare Split-Punkte als auch das Übereinanderlegen von Sounds kein Problem darstellen sollte.

Was jedoch, wenn die Gitarre zu tief klingt, weil wir sie der linken Tastaturhälfte zugeordnet haben? Das Masterkeyboard sollte in der Lage sein, jeden einzelnen Bereich in die gewünschte Tonlage zu transponieren. Damit wären auch schon die Grundfunktionen geklärt, die man mit einem ganz einfachen Keyboard realisieren kann.

Weitere Funktionen hängen davon ab, was das Keyboard, das man als Masterkeyboard verwenden möchte, noch an technischen Besonderheiten zu bieten hat. Ist es anschlagsdynamisch? In diesem Fall ist es sinnvoll, wenn man jeden Bereich in seiner Lautstärke hervorheben oder abschwächen kann. Verfügt das Keyboard über eine After-Touch-Funktion, um spezielle Effekte wie zum Beispiel ein Vibrato durch stärkeren Tastendruck hinzuzumischen? In diesem Fall sollte man bestimmen können, ob für einen Tastaturbereich dieser Effekt gestattet werden soll oder nicht. Gleiches gilt auch für weitere Besonderheiten wie Pitch-Bender, Steuerräder und Joysticks, die den Sound in der Tonhöhe oder im Klang beeinflussen.

Wie lassen sich all diese Funktionen programmtechnisch realisieren? Untersuchen wir hierzu zunächst einma1, was passiert, wenn auf dem Keyboard eine Taste heruntergedrückt und wieder losgelassen wird. Beim Herunterdrücken wird man feststellen, daß drei Bytes gesendet werden. Das erste Byte ist ein sogenanntes Status-Byte. Die ersten vier Bits oder das erste Nibble beinhalten die Information, daß eine Taste heruntergedrückt wurde (Note_on HEX=9). Das zweite Nibble teilt mit, auf welchem Midikanal gesendet wurde (0-15). Das zweite Byte stellt die Notennummer dar. Jeder Taste auf dem Keyboard ist eine Notennummer zugeordet. Das dritte Byte beinhaltet schließlich die Anschlagsstärke (Velocity). Beim Loslassen der Taste passiert das gleiche, nur daß statt der Meldung Note_On die Meldung NotejDff als erstes Byte (High Nibble: HEX=8) gesendet wird. Bei den speziellen Funktionen wie After-Touch und Pitch-Bend läuft die Sache ähnlich. Zunächst wird wieder das Status-Byte gesendet, dann bei After-Touch ein weiteres Daten-Byte und bei Pitch-Bend zwei weitere, die jeweils die Intensität des Effektes festlegen.

Um all diese Parameter unter Kontrolle zu behalten, benutzen wir den Atari-ST als Filter, der zunächst sämtliche Daten einliest, sie modifiziert und so, wie wir sie benötigen, sendet.

Wie funktioniert der Masterkeyboard-Simulator? Sobald ein Byte gesendet wird, wird festgestellt, ob es sich um ein Status-Byte handelt, das wir weiterverwenden möchten oder nicht. Einige Keyboards senden zum Beispiel sogenannte System-Echtzeitmeldungen wie Active-Sensing oder Midi-Clock-Signale, die wir in unserer einfachen Masterkey board-Simulation nicht berücksichtigen möchten. Solche Meldungen werden einfach ignoriert. Es wird solange gewartet, bis eine Note_On-, Note_Off-, After_Touch- oder Pitch_Bender-Meldung gesendet wird. Ist dies der Fall, springt das Programm in die Prozedur, in der die entsprechende Meldung gemäß den vorgegebenen Parametern, die am Programmanfang den zuständigen Variablen zugewiesen wurde, ausgewertet yvird. Bei Pitch_Bend- und After_Touch-Meldungen wird abgefragt ob sie für einen bestimmten Keyboard-Bereich zugelassen wurden oder nicht. Sind sie nicht zugelassen, werden sie ignoriert, andernfalls entsprechend dem vorgegebenen Midikanal gesendet.

Bei Note_On- und Note_Off-Meldungen wird zunächst festgestellt, in welchem Bereich der Tastatur sie sich befinden.

Befindet sich die Taste in einem vordefinierten Bereich, wird der Ausgabekanal gesetzt, die Notennummer in die gewünschte Tonlage transponiert und die Anschlagsdynamik entsprechend einem vorgegebenen Velocity-Faktor berechnet (Velocity_Faktor=100, volle Dynamik).

Natürlich beschränkt sich diese Masterkeyboard-Simulation nur auf die Standardmeldungen, die von fast jedem Keyboard oder Synthesizer gesendet werden. Aber letztendlich sollen hier nur Anregungen gegeben werden, wie man sein Keyboard und seinen Midiexpander noch besser ausnutzen kann. Im Regelfall liegt jedem midifähigen Instrument eine Liste bei, in der die Midimeldungen aufgeführt sind, die das Instrument senden und empfangen kann. Warum also nicht ein wenig herumexperimentieren und die Masterkeyboard-Simulation der eigenen Konfiguration, entsprechend den vorhandenen Möglichkeiten, anpassen? Viel Spaß beim Experimentieren!

' ***************************
' *      MASTERKEYBOARD     *
' *        Simulation       *
' *    GFA-BASIC-Listing    *
' * (c) 1992 MAXON Computer *
' ***************************
'
' STATUSBYTES - (HIGH Nibble)
note_off%=&H8
note_on%=&H9
after_touch%=&HD
pitch_bend%=&HE
'
ja%=-1 
nein%=0
'
n_bereiche%=2 !3 Bereiche (einschliesslich Null) 
DIM bereich_anfang%(n_bereiche%), bereich_ende%(n_bereiche%)
DIM ausgabekanal%(n_bereiche%), transpose%(n_bereiche%)
DIM after_touch_zugelassen%(n_bereiche%)
DIM pitch_bend_zugelassen(n_bereiche%)
DIM velocity_faktor%(n_bereiche%)
'
' ****************************************
' * Parameter für die Keyboardaufteilung *
' ****************************************
'
' Beispiel 
' Erster Bereich 
bereich_anfang%(0)=36 
bereich_ende%(0)=59 
ausgabekanal%(0)=0 
transpose%(0)=0 
velocity_faktor%(0)=100 
after_touch_zugelassen% (0) = ja% 
pitch_bend_zugelassen%(0)=ja%
'
' Zweiter Bereich 
bereich_anfang%(1)=60 
bereich_ende%(1)=96 
ausgabekanal%(1)=1 
transpose%(1)=-12 
velocity_faktor%(1)=70 
after_touch_zugelassen%(1)=nein% 
pitch_bend_zugelassen%(1)=nein%
'
' Dritter Bereich 
bereich_anfang%(2)=36 
bereich_ende%(2)=96 
ausgabekanal%(2)=2 
transpose%(2)=12 
velocity_faktor%(2)=50 
after_touch_zugelassen%(2)=nein% 
pitch_bend_zugelassen%(2)=nein%
'
REPEAT
	REPEAT
		gesendet%=BIOS(1,3)
		IF INKEY$< >"" 
			programmende 
		ENDIF
	UNTIL gesendete ! Wenn ein MIDI-Byte anliegt geht's weiter
	'
	lese_midibyte
	'
	statusbyte%=byte%\16 !HIGH Nibble isolieren
	'
	IF statusbyte%=note_on% OR statusbyte%=note_off% 
		lese_datenbyte 
		notennummer%=byte% 
		lese_datenbyte 
		velocity%=byte%
		FOR i%=0 TO n_bereiche%
			IF notennummer%>=bereich_anfang%(i%) AND notennummer%<=bereich_ende%(i%)
				VOID BIOS(3,3,statusbyte%*16 + ausgabekanal%(i%))
				VOID BIOS(3,3,notennummer%+transpose%{i%)) 
				VOID BIOS(3,3,(velocity%/100) * velocity_faktor%(i%))
			ENDIF 
		NEXT i%
	ENDIF
	'
	IF statusbyte%=after_touch% 
		lese_datenbyte 
		FOR i%=0 TO n_bereiche%
			IF after_touch_zugelassen%(i%)
				VOID BIOS(3,3,statusbyte%*16+ ausgabekanal%(i%))
				VOID BIOS(3,3,byte%)
			ENDIF 
		NEXT i%
	ENDIF
	'
	IF statusbyte%=pitch_bend% 
		lese_datenbyte 
		l_byte%=byte% 
		lese_datenbyte 
		h_byte%=byte%
		FOR i%=0 TO n_bereiche%
			IF pitch_bend_zugelassen%(i%)
				VOID BIOS(3,3,statusbyte%*16+ausgabekanal%(i%))
				VOID BIOS(3,3,l_byte%)
				VOID BIOS(3,3,h_byte%)
			ENDIF 
		NEXT i%
	ENDIF
	'
UNTIL INKEY$< >""
'
programmende
'
PROCEDURE programmende 
	END
RETURN
'
PROCEDURE lese_midibyte 
	r%=BIOS(2,3)
	byte%=r%+256 ! Weil die BIOS-Funktion einen negativen Wert ausgibt
RETURN

PROCEDURE lese_datenbyte 
	REPEAT
		lese_midibyte 
	UNTIL byte%<128 ! Eventuelle Echtzeitmeldungen ausfiltern
RETURN