FutureOS Midi Trakker

[TFM]

Der Gruppierungs-Balken wird real nicht zu sehen sein, da wir bei 94 Zeichen mit 21 Zeilen arbeiten werden. Der Balken dient hier nur der Übersichtlichkeit.
Ansonsten sind die Spuren durch 'normal' und 'invers' zu unterscheiden.

Wenn's keine Ideen mehr dazu gibt, dann kann ich das ja mal umsetzen auf CPC.
Aber wer weiß, vielleicht gibt's ja noch gute Ideen? 

[LambdaMikel]

Ich denke, das sollte für den Anfang erstmal reichen. Natürlich brauchen wir auch soetwas wie Load and Save, und die Möglichkeit, verschiedene Patterns zusammenzuketten / Song-Ablauf. Das sollten allerdings weitere Masken sein; das kommt also später.

[TFM]

Ja, mit 84 Spalten und 24 Zeilen würde es dann so aussehen:

---=====-----=====-----=====-----=====-----=====-----=====-----=====-----=====-----
01|0 C8 1 CA 2 CB 3 C8 4 64 5 C8 6 01 7 7B 8 C8 9 CA A CB B C8 C 64 D C8 E 01 F 7B
--+=====-----=====-----=====-----=====-----=====-----=====-----=====-----=====-----
00|C-2 FC-2 FC-2 FC-2 FC-2 FC#2 ED-0 CC-2 9C-2 7C-2 DC-2 5C-2 FC-2 EC#2 AD-0 EC-2 F
01|A-4 EC-2 FC-2 FC-2 FC-2 FC#2 ED-0 CC-2 9C-2 7C-2 DC-2 5C-2 FC-2 EC#2 AD-0 EC-2 F
02|E-2 DC-2 FC-2 FC-2 FC-2 FC#2 ED-0 CC-2 9C-2 7C-2 DC-2 5C-2 FC-2 EC#2 AD-0 EC-2 F
03|C-5 FC-2 FC-2 FC-2 FC-2 FC#2 ED-0 CC-2 9C-2 7C-2 DC-2 5C-2 FC-2 EC#2 AD-0 EC-2 F
04|C-2 FC-2 FC-2 FC-2 FC-2 FC#2 ED-0 CC-2 9C-2 7C-2 DC-2 5C-2 FC-2 EC#2 AD-0 EC-2 F
05|C-2 EC-2 FC-2 FC-2 FC-2 FC#2 ED-0 CC-2 9C-2 7C-2 DC-2 5C-2 FC-2 EC#2 AD-0 EC-2 F
06|C-2 FC-2 FC-2 FC-2 FC-2 FC#2 ED-0 CC-2 9C-2 7C-2 DC-2 5C-2 FC-2 EC#2 AD-0 EC-2 F
07|C-2 FC-2 FC-2 FC-2 FC-2 FC#2 ED-0 CC-2 9C-2 7C-2 DC-2 5C-2 FC-2 EC#2 AD-0 EC-2 F
08|C-2 FC-2 FC-2 FC-2 FC-2 FC#2 ED-0 CC-2 9C-2 7C-2 DC-2 5C-2 FC-2 EC#2 AD-0 EC-2 F
09|C-2 FC-2 FC-2 FC-2 FC-2 FC#2 ED-0 CC-2 9C-2 7C-2 DC-2 5C-2 FC-2 EC#2 AD-0 EC-2 F
0A|C-2 FC-2 FC-2 FC-2 FC-2 FC#2 ED-0 CC-2 9C-2 7C-2 DC-2 5C-2 FC-2 EC#2 AD-0 EC-2 F
0B|C-2 FC-2 FC-2 FC-2 FC-2 FC#2 ED-0 CC-2 9C-2 7C-2 DC-2 5C-2 FC-2 EC#2 AD-0 EC-2 F
0C|C-2 FC-2 FC-2 FC-2 FC-2 FC#2 ED-0 CC-2 9C-2 7C-2 DC-2 5C-2 FC-2 EC#2 AD-0 EC-2 F
0D|C-2 FC-2 FC-2 FC-2 FC-2 FC#2 ED-0 CC-2 9C-2 7C-2 DC-2 5C-2 FC-2 EC#2 AD-0 EC-2 F
0E|C-2 FC-2 FC-2 FC-2 FC-2 FC#2 ED-0 CC-2 9C-2 7C-2 DC-2 5C-2 FC-2 EC#2 AD-0 EC-2 F
0F|C-2 FC-2 FC-2 FC-2 FC-2 FC#2 ED-0 CC-2 9C-2 7C-2 DC-2 5C-2 FC-2 EC#2 AD-0 EC-2 F
--+=====-----=====-----=====-----=====-----=====-----=====-----=====-----=====-----
07|RMS*+RMS*+RMS*+RMS*+RMS*+RMS*+RMS*+RMS*+RMS*+RMS*+RMS*+RMS*+RMS*+RMS*+RMS*+RMS*+
TEMPO:120  |>  []  S O P  PCLCK[X]  RCLCK[X]  RANGE:10-61[X]  PUNCH:20-30[X]  LS[X]
Load Song  Save Song  Load Pattern  Save Pattern  Make Song
--+=====-----=====-----=====-----=====-----=====-----=====-----=====-----=====-----

[LambdaMikel]

Das scheint mir ein guter Kompromiss zwischen Lesbarkeit und Darstellung zu sein!
So jetzt habe ich doch noch eine Idee, angeregt durch Deinen Menü-Balken unten: lass uns doch auch noch das Song Pattern dort haben, und ebenfalls Stelle für Stelle editierbar machen. Also

Load Song  Save Song  Load Pattern  Save Pattern  [0,1,0,1,2,3,4,5,1,0,A, ...]

Wieviele Stellen haben wir denn?  Richtig nett wäre, wenn man auch den Pattern_Range angeben könnte:

LSng  SSng LPat  SPat Song: [0:00-63 1:32-63 0:60-20 1:10-20 ...]   

LSng, SSng etc. können ja Single Character sein, dann haben wir mehr Platz!

[TFM]

Aktuell arbeiten wir mit 84 Spalten, wie die zusätzliche Zeile aussieht, das überlasse ich ganz Dir. 

[TFM]

Jetzt geht's zur Anzeige... Wir haben ja pro Schritt(Step) und Kanal jeweils 5 Zeichen Platz nebeneinander.

MIDI sagt folgendes:
The NOTE ON message is structured as follows:
•   Status byte : 1001 CCCC
•   Data byte 1 : 0PPP PPPP
•   Data byte 2 : 0VVV VVVV
where:
"CCCC" is the MIDI channel (from 0 to 15)
"PPP PPPP" is the pitch value (from 0 to 127)
"VVV VVVV" is the velocity value (from 0 to 127)

Und nun ein paar Fragen bezüglich einem Datensatz / den Daten im RAM für unseren Trakker

1. Brauchen wir das Status Byte? Oder verzichten wir daraus, aber kann wäre es immer nur 'Note an' und kein 'Note aus' möglich.

2. Wie stelle ich 'PPP PPPP' am besten dar?

3. Wie stelle ich 'VVV VVVV' am besten dar?

Da frage ich mich schon seit Tagen, wie wir das am besten machen. Wie die Daten in Speicher ablegen?
Und wie die Daten am Bildschirm darstellen? Also welchen Wert sieht wie aus? Welchen Wert hat ein "C-2" etc. Hab da zwar mal eine Tabelle gesehen, aber ich find die nimmer.

[LambdaMikel]

Hallo TFM,

für eine Note On / Off message brauchen wir nur 2 Bytes pro Step.

1. das CCCC ("Statusbyte") ist der MIDI Kanal, den brauchen wir nicht speichern "pro Step", da jede "Spur" nur einen Kanal haben kann, der pro Spur festgelegt wird. Das ist also implizit und wird beim Abspielen der Spur hinzugefügt.

2. Byte 1 = Notenrange / Pitch ist von 0 bis 127: 0 = C-1, 128 = G-9. 
3. Byte 2 = Velocity / Volume

https://studiocode.dev/resources/midi-middle-c/

Für die 5 Zeichen pro MIDI NOTE ON Message haven wir als 3 Zeichen für die Note, und dann 2 Zeichen für Velocity. 0 bis 7F. 
Ich hatte hier ebenfalls die Idee, das auf 0 - F zu begrenzen, und dann beim Abspielen auf 0 bis 127 abzubilden. Dann hätten wir noch ein Zeichen frei für... etwas anderes :-)

Und dann müssen wir noch NOTE OFF darstellen! Wenn in MIDI eine Note On message kommt, muss die auch wieder "abgeschaltet" werden. Zwischen An- und Abschalten der Note muss ebenfalls etwas dargestellt werden. Also z.B. soetwas

00 C-1 70
01 .........
02 .........
03         
04 C-2 80
05
06

Idee ist also, dass "......" das "Halten" der Note visualisiert. Und "     " ist eben "Step ist leer". 

Für Note On / Off also 2 Bytes pro Step.

EDIT : Für eine Control Change message (CC) brauchen wir maximal 2 Bytes pro Step. Wie gesagt, eine Spur / Track kann entweder nur CC Spur oder Note On / Note Off Spur sein. Wiederum wird der Kanal durch die Spur festgelegt.

CC Messages / Spuren sind ohnehin "forgeschrittenes Zeug", wir können das erstmal komplett ignorieren und nur Noten-Spuren implementieren. CC-Spuren können später kommen.

Das ist eine recht gut Darstellung:

https://www.midi.org/midi-articles/about-midi-part-3-midi-messages


Note On / Note Off / Velocity

In MIDI systems, the activation of a particular note and the release of the same note are considered as two separate events. When a key is pressed on a MIDI keyboard instrument or MIDI keyboard controller, the keyboard sends a Note On message on the MIDI OUT port. The keyboard may be set to transmit on any one of the sixteen logical MIDI channels, and the status byte for the Note On message will indicate the selected Channel number. The Note On status byte is followed by two data bytes, which specify key number (indicating which key was pressed) and velocity (how hard the key was pressed).

The key number is used in the receiving synthesizer to select which note should be played, and the velocity is normally used to control the amplitude of the note. When the key is released, the keyboard instrument or controller will send a Note Off message. The Note Off message also includes data bytes for the key number and for the velocity with which the key was released. The Note Off velocity information is normally ignored.

Und in unserer "CC Spur" brauchen wir die folgenden Messages - wie man sieht, brauchen einige 2, endere 3 Bytes. Wiederum ist das 1. Bytes durch die Spur festgelegt (Kanal), so dass wir nur 2 Bytes pro Step speichern müssen. Bei einigen Messages wird das 2. Byte pro Step nicht benötigt.

Pitch Bend

The Pitch Bend Change message is normally sent from a keyboard instrument in response to changes in position of the pitch bend wheel. The pitch bend information is used to modify the pitch of sounds being played on a given Channel. The Pitch Bend message includes two data bytes to specify the pitch bend value. Two bytes are required to allow fine enough resolution to make pitch changes resulting from movement of the pitch bend wheel seem to occur in a continuous manner rather than in steps.

Control Change

MIDI Control Change messages are used to control a wide variety of functions in a synthesizer. Control Change messages, like other MIDI Channel messages, should only affect the Channel number indicated in the status byte. The Control Change status byte is followed by one data byte indicating the "controller number", and a second byte which specifies the "control value". The controller number identifies which function of the synthesizer is to be controlled by the message. A complete list of assigned controllers is found in the MIDI 1.0 Detailed Specification.

Und dann bruachen wir noch Program Change - damit wird das Instrument pro Kanal festgelegt. Das wird pro Spur festgelegt, und beim Abspielen / Starten des Abspielens werden alle Kanäle mit den richtigen Instrument eingestellt per Program Change, danach sind die SPuren fest. D.h., wir brauchen keine Program Change "pro Step":

Program Change

The Program Change message is used to specify the type of instrument which should be used to play sounds on a given Channel. This message needs only one data byte which specifies the new program number.

Zudem gibt es noch Bank Select:

- Bank Select

Controller number zero (with 32 as the LSB) is defined as the bank select. The bank select function is used in some synthesizers in conjunction with the MIDI Program Change message to expand the number of different instrument sounds which may be specified (the Program Change message alone allows selection of one of 128 possible program numbers). The additional sounds are selected by preceding the Program Change message with a Control Change message which specifies a new value for Controller zero and Controller 32, allowing 16,384 banks of 128 sound each.

Was also gut wäre - wenn wir die "Spur-Kopfzeilen" so ändern könnten, dass wir

1. Kanal-Nummer (0-F)
2. Instrumenten-Nummer (0-7F)
3. Bank-Nummer  (0-7F)

sehen könnten. 5 Zeichen :-)

---=====-----=====-----=====-----=====-----=====-----=====-----=====-----=====-----
01|0680012A0021B01 

[TFM]

Das ist ganz schön kompliziert, muss ich mir morgen nochmal durchlesen.
Der erste Link geht bei mir nicht, der zweite schon.

Bei Deinem Vorschlag die Kopfzeile zu ändern, da sind aber Wert größer 7F drin. Warum ist das so.

Was anderes: Du hast doch mal einen Aufbau gehabt, bei dem Du ein MIDI Lied quasi durch den CPC geschickt hast.
Es wäre super, wenn ich da mal so ca. 1 KB bis 16 KB von so einem Datenstrom als Datei (gerne Binär) haben könnte. Einfach um zu sehen was das an Daten verschickt wird. Das würde mir helfen den internen Aufbau von Daten im CPC-MIDI-Tracker zu planen.

[LambdaMikel]

@TFM, have ne Idee:
wie wäre es, wenn ich in BASIC einen (funktionablen, aber langsamen) Prototypen schreiben würde (mit weniger Tracks dann). Dann hätten wir Klarheit, und es ist für mich ebenfalls einfacher das Display konzeptuell zu entwerfen etc. Evtl. ohne Realtime MIDI Input. Aber Eingabe soll ja auch über Tastatur möglich sein. Realtime sequencing ist dann etwas, das nur die FutureOS Version kann.

Die GM MIDI-Daten helfen nicht viel, da dort zu viel "Noise" drin ist. Die zu generierenden MIDI Daten sehen ganz anders aus, und die Speicherdarstellung ist noch einmal anders.

Die MIDI Datein  (aber auch das MC-Abspielprogram) sind in den "Song" binaries. S. run "song2.bin". Erzeugt wurde da BIN vom RECORDE2.BAS MAXAM Programm. Die MIDI Daten sind glaube ich ab Adresse @MIDIRAMADR bis @MIDIEND

Viele Grüße
Michael

[TFM]

@TFM, habe ne Idee:
wie wäre es, wenn ich in BASIC einen (funktionablen, aber langsamen) Prototypen schreiben würde (mit weniger Tracks dann). Dann hätten wir Klarheit, und es ist für mich ebenfalls einfacher das Display konzeptuell zu entwerfen etc.

Gute Idee! Dann sehe ich auch gleich welche Zahlenwerte wie am Bildschirm dargestellt werden.
Aber bitte so simple wie möglich. 

[LambdaMikel]

Na ja, man soll ja auch mal was Neues machen. Für mich also kein BASIC; sondern das hier:

https://hackaday.com/2021/11/30/turbo-rascal-is-the-retro-pascal-compiler-we-always-wanted/

[TFM]

Also... hab mal kurz reingelesen. Klingt interessant... lese mir das jetzt in Ruhe durch. 

EDIT: Also, egal welche Sprache Du benutzt. Wenn wir das dann in Z80 Code umsetzten wollen, dann wäre es gut mit einem statischen Bildschirm zu arbeiten. Das heißt anstatt zu Scrollen den Bildschirm zu löschen. So fängt der Bildschirmspeicher immer an &C000 an. Dadurch läßt sich vieles schneller programmieren. 

EDIT2: Beim Anzeigen der MIDI Daten hat es allerdings durchaus Sinn den Hardware-Scroll zu verwenden. Das ist aber dann eine spezielle Sache mit ein paar Tricks die alle schön schnell machen.

[LambdaMikel]

Ja, klingt gut! Alles klar, bin momentan etwas versumpft und möchte dann demnächst ersteinmal das Python-Programm zur Erstellung von MIDI Songs machen (damit man Song-Disks erstellen kann). Danach (neues Jahr) geht's dann los!

[TFM]

Ja, lassen wir's gut sein für dieses Jahr, ich komm momentan auch zu nix. November war schon nervig, der Dezember will uns wohl auch in Erinnerung bleiben.  Einfach mal alles locker angehen lassen, ist ja vor allem Hobby und soll Spass machen. 

[TFM]

So, jetzt habe ich mir mal überlegt wie wir das hübsch und Platz-sparend auf dem Bildschirm darstellen können.

Gehen wir davon aus, dass ein MIDI Kommando aus 3 Bytes besteht, also 6 Zeichen am Bildschirm braucht. Und stellen wir diese 3 Bytes als Hexadezimal-Zahlen dar, genau so wie die MIDI-Kommandos eben sind. Dann könnte folgendes funktionieren:

Kanalstatus
-----------
16 Kanäle mit je 6 Zeichen werden benötigt = 96 Zeichen
Wenn man je 6 Zeichen auf 5 Bytes aufteilt, sind es 80 Zeichen

Darstellung von 6-Punkt Zeichen innerhalb von Bytes - 6 Zeichen in 5 Bytes
--------------------------------------------------------------------------
0000 0000 | 1111 1111 | 2222 2222 | 3333 3333 | 4444 4444 | Byte-Format
----------+-----------+-----------+-----------+-----------+---------------
00AA AAAA | BBBB BBCC | CCCC DDDD | DDEE EEEE | FFFF FF00 | Zeichen-Format

6-Bit Zahlen und Buchstaben
---------------------------
- Die oberste Rasterzeile bleibt dabei immer frei.
  So kann sie als 9. Rasterzeile (ebenfalls leer) genutzt werden.
- Die rechte (also 6.) Pixel-Spalte bleibt auch immer frei.
  Die Zeichen beginnen also im ersten Bit, das 6. ist '0'

XXX      X      XXX     XXX
X   X    XX     X   X   X   X
X   X     X         X       X
X X X     X        X     XXX
X   X     S       X         X
X   X     X      X      X   X
XXX     XXX    XXXXX    XXX

X       XXXXX    XXX    XXXXX
X X     X       X   X       X
X X     X       X           X
XXXXX   XXXX    XXXX      X
  X         X   X   X     X
  X         X   X   X     X
  X     XXXX     XXX      X

XXX     XXX      X     XXXX
X   X   X   X    X X    X   X
X X    X   X   X   X   X   X
  X      XXXX   XXXXX   XXXX
X X        X   X   X   X   X
X   X   X   X   X   X   X   X
XXX     XXX    X   X   XXXX

XXX    XXX     XXXXX   XXXXX
X   X   X  X    X         X
X       X   X   X         X
X       X   X   XXX      XXX
X       X   X   X         X
X   X   X  X    X         X
XXX    XXX     XXXXX     X



P.S.: Auf dem Grünmonitor wird das erst so richtig schön.