Build your OS – Bellatrix-Code

bellatrix-code2Inhaltsverzeichnis

Logbuch
Einleitung
Teil 1 – Der Plan
Teil 2 – Ein einfaches Hive-OS – Schritten für Schritt
_Bellatrix-Code
____Erste Lebenszeichen
____Bildschirm löschen
____Eine zweite Zeile
____Zahlenausgabe
____Tastatur und VGA
____Freestyle

Logbuch

09.09.2009 – erste Version

Einleitung

Dieses grundlegende Tutorial behandelt folgende Themen:

  • Struktur des Propeller-Mikrocontrollers
  • Struktur des Hive
  • Erste Schritte bei der Erstellung von Software auf dem Hive am Beispiel der Entwicklung eines eines einfachen Betriebssystems
  • Aufbau und Funktion von TriOS

In diesem Tutorial nun möchte ich eine Hilfe für den Einstieg in die Entwicklung von Software für den Hive-Computer geben. Dabei richtet sich der Inhalt an Einsteiger, weshalb mir die Profis unter uns einige Vereinfachungen und vielleicht nicht ganz perfekte Ansätze verzeihen mögen, denn es geht in diesem Text nicht um absolute Perfektion, sondern vordergründig um einen einfachen und leichten Einstieg. Pragmatismus statt Perfektion, Übersichtlichkeit und Verstehbarkeit statt maximaler Performance ist hier das Zauberwort.

Im übrigen entspricht der Hive und das TriOS meiner Vorstellung von „Spaß an der Technik“ – denn genau das war die Wurzel des ganzen Übels. Deshalb hoffe ich, dass sich konzeptuelle Kritik mehr in eigener Kreativität manifestiert als in großen Anpassungswünschen, denn die Frage warum der Hive und das TriOS genau so ist wie es ist, ist ganz einfach: Weil sie mir genau so Spaß machen. Wenn die Freude bei anderen Hive-Drohnen (Für die Ungläubigen – Drohne: Bezeichnung eines Hive-Users; im allgemeinen wir die gemeine Drohne noch mit einem Index versehen, welcher die Seriennummer des eigenen Hives angibt – zum Beispiel Drohne023, Erbauer des Hives023) kompatibel ist, bin ich mehr als zufrieden, wenn nicht, ist der Hive und TriOS viel zu einfach, um nicht kreativ einen eigenen Weg zu mehr Spaß im Leben zu finden.

Und genau das soll der Punkt sein: Als ich den ersten Hive aufbaute, hab ich mit dem ersten Chip experimentiert und eine Menge Spaß gehabt; hab mit dem zweiten Chip experimentiert und noch mehr Spaß gehabt; hab Regnatix zum Leben erweckt und die Sache lief. Das war keine Lernarbeit oder Anstrengung, die Sache ist einfach und leicht wie Lego – die Propellerchips laden geradezu zum spielen und experimentieren ein. Das Ganze sollte ja kein PC-Clone werden, sondern einfach etwas, was sich anfühlt wie ein Retrocomputer. Also werft jetzt mal alles was ihr bisher über Monster-Betriebssysteme gehört habt und was ihr von diesen erwartet über Bord, denn jetzt wird es wieder ganz minimalistisch: Wir wollen, dass ein paar Siliziumsplitter, ein wenig Kupfer und Plastik, das wir mit den eigenen Händen zusammengelötet haben, geordnet auf ein paar Befehle reagiert – und das in einer möglichst einfachen und verständigen Art und Weise. Nicht mehr und nicht weniger, denn viel mehr gab es bei den Retros auch nicht.

Aber zurück zum Pragmatismus: Letztlich ist dieser Ansatz auch die Grundlage von TriOS, denn dieses System ist ursprünglich als „Werkstattcode“ aus dem Bedürfnis entstanden, eine einfache und ausreichend schnelle Basissoftware auf dem Hive zu realisieren, um während der Entwicklung Tools oder Testsoftware zu starten. Momentan sind auch noch andere Betriebssysteme in der experimentellen Phase, teilweise wahrscheinlich wesentlich leistungsfähiger und universeller als TriOS, aber teilweise unter Opfergabe der Orientierung an der Programmiersprache SPIN. Ich persönlich bin da sehr gespannt.

Dennoch bin ich mir sicher, das TriOS oder andere rein an SPIN orientierte Lösungen einen wichtigen Platz im Hive-Universum einnehmen werden, denn die Integration der Sprache SPIN in das Konzept der Propellerchips ist in ihrer Weise durchaus genial und an Einfachheit schwer zu überbieten. Obwohl man momentan noch einen Hostcomputer mit dem Propeller Tool benötigt, um in SPIN zu programmieren, erinnert mich diese Einfachheit und Unbeschwertheit im Umgang doch sehr an die Art, wie man damals auf den alten Homecomputern in den verschiedenen integrierten Basic-Dialekten programmiert hat – nur das SPIN dabei wesentlich strukturierter und leistungsfähiger ist.

Von diesen Aspekten abgesehen ist SPIN auch für sehr viele Anwendungen ausreichend schnell und bietet über die Integration von PASM-Code auch in fortgeschrittenem Stadium die Möglichkeit, meist nur punktuell auftretende Performance-Flaschenhälse durch RISC-Maschinencode nochmals um den Faktor 50..100 gegenüber SPIN zu beschleunigen.

Fest steht: Nichts ist momentan besser in die Propellerchips integriert und auch einfacher als die Kombination aus SPIN und dem Propeller Tool. Und das gilt nicht nur für die ersten Schritte auf dem Hive, sondern auch für all jene Interessierten, welche ganz andere Hardwareprojekte mit den Propellerchips realisieren wollen. Aber dieser Thron kann auch sehr schnell wackeln – vielleicht gibt es auch bald ein Forth- oder ???-Tutorial zum Hive…

Für wen ist also TriOS interessant:

  1. Alle Einsteiger, welche ihre ersten Schritte mit dem Propellerchip machen und mit diesem phantastischen Schaltkreis ein wenig warm werden wollen.
  2. Alle Interessierten, die den Hive mehr unter dem Aspekt „Homecomputer“ aufbauen und vielleicht noch einmal genauer etwas über die Grundlagen der Computertechnik wissen wollen.
  3. Wer aus Spaß an der Freude selbst mal ein kleines Game oder andere Software programmieren möchte.
  4. Wer ein einfaches System für einfache Hardware- oder Softwareexperimente sucht.

Diese Eckpunkte sollten den Rahmen für TriOS abstecken. Nicht jeder fängt gleich an in Assembler zu programmieren, obgleich genau das letztlich ganz gut in SPIN integriert ist. Somit bleibt das System auch auf längere Zeit hin ausbau- und entwicklungsfähig.

Neben SPIN und einem darauf basierenden OS hat in meinen Augen nur noch Forth das Potential den Hive und die Propellerchips in ihrer Eigenart in noch viel umfassenderen Maße zu ergänzen. Wenn ein echtes Multikern-Forth verfügbar wird, haben wir mit einem Streich eine ganz einzigartige Systemsoftware verfügbar:

  • Das Hive-Forth wird sowohl Compiler wie auch Interpreter sein, womit automatisch das erste echte Programmiersystem ohne die Unterstützung eines Hostcomputers verfügbar wird.
  • Forth kann als erweiterbarer Kommandozeileninterpreter und als Skriptsprache Verwendung finden.
  • Forth wird auf den Propellerchips deutlich schneller als Spin und etwas langsamer als PASM – aber das ganze als Interpreter und Compiler!
  • Forth verwaltet Speicher und Ressourcen und hat damit Aspekte eines einfachen Betriebssystems.

Naja, damit hat Forth eigentlich alles was man auf dem Hive braucht, oder wie Forthler mit einem Augenzwinkern zu sagen pflegen: „Forth ist die Antwort, was war doch gleich die Frage?“ Ich denke allein diese Aspekte machen das ganze extrem interessant und es scheint mir persönlich, das Forth zum Propeller passt wie die Faust aufs Auge.

Ich habe versucht diese Anleitung so zu gestalten, das sie parallel zum Tutorial „Build your Hive“ verwendet werden kann. Natürlich ist dabei eine Voraussetzung, das man den Aufbau des Hives schon bis zum ersten Propellerchip bewältigt hat. In der Aufbaubeschreibung habe ich empfohlen, als erstes Bellatrix in Betrieb zu setzen, um die Möglichkeit zu schaffen, mit einem angeschlossenen VGA-Monitor und einer Tastatur interaktiv zu experimentieren. Durch diese Parallelität der beiden Tutorials kommt es an einigen Stellen zu Wiederholungen und Überschneidungen, aber auch zu dem gewollten Effekt, dass beide Texte sich gegenseitig befruchten und das Verständnis vertiefen.

Als großes Beispiel und als roter Faden für die ersten Schritte bei der Entwicklung von Software für den Hive dient wieder ganz pragmatisch die Entwicklung eines einfachen Betriebssystems. TriOS ist dafür das ideale Objekt, denn es ist quasi nebenbei bei der Entwicklung und beim Aufbau des Hive entstanden. Damit wird die enge Verbindung zur Entstehung des Gerätes deutlich und es wird sicher auch klar, das die Logik hinter TriOS gut verstanden werden kann, wenn man einfach die Entwicklung und schrittweise Entstehung des Gerätes nachvollzieht.

Und genau das ist auch der Plan: Im ersten Teil werden wir detailliert die schrittweise Entstehungsgeschichte nachvollziehen, schrittweise den Propellerchip und die Struktur des Hive-Computers erkunden und die Entwicklung der Hardware indirekt oder direkt – je nachdem ob der eigene Hive schon soweit komplettiert ist – mit der entsprechenden Software zum Leben erwecken.

Im zweiten Teil wenden wir uns dann dem TriOS in seiner momentanen Form zu, schauen wie das System installiert wird und untersuchen die Funktionskomplexe und die korrespondierenden IOS-Funktionen etwas genauer. Abschließend folgt ein Ausblick auf mögliche Entwicklungen und Möglichkeiten des dargestellten Systems. Letztlich sollte man nach dem Aufbau des Hives und dem Absolvieren dieses Tutorials in der Lage sein, den Propeller, das gesamte Gerät und TriOS grundlegend zu verstehen und vielleicht auch eigene Software bis hin zum eigenen Betriebssystem zu erstellen.

Aber genug der langen Worte, lasst uns mit dem Spaß beginnen…

Teil 1 – Der Plan

Untersuchen wir als erstes was wir haben und was wir wollen. Am Anfang stand eine Idee: Kann man mit den heutigen Mittel einen einfachen Homecomputer selbst entwickeln? Eines stand dabei fest: Ein solches Gerät ist nicht mit einem einzigen Chip zu realisieren, weshalb ich die einzelnen Funktionen auf drei Propeller verteilte. Betrachtet man es genau, so hat man drei kleine Computer die im Hive parallel arbeiten. Jedes dieser drei Subsystem ist wieder in acht RISC-Subsysteme geteilt, welche auf gemeinsame Ressourcen innerhalb des Schaltkreises zugreifen, wie Speicher und I/O-Leitungen.

Im Artikel „Wie alles anfing“ kann man recht genau nachlesen wie ich den ersten Hive aufgebaut habe, angefangen mit dem Bellatrix-Chip und auch im Tutorial zum Aufbau „Build your Hive“ empfehle ich diese Reihenfolge nachzuvollziehen. Da Bellatrix im Konzept den Funktionskomplex der Benutzerschnittstelle (VGA, TV, Keyboard, Maus) realisiert, kann man sehr gut erste interaktive Experimente durchführen.

Was wir letztlich wollen, ist die Realisierung eines einfachen Betriebssystems. Das war nicht unbedingt so geplant, aber die besondere verteilte Struktur des Hive brachte es letztlich mit sich, dass sich „verteilt“ über mehrere Stufen auch das Betriebssystem TriOS nebenher herauskristallisiert hat.

Wozu braucht man eigentlich ein Betriebssystem? In Wirklichkeit gibt es wahrscheinlich in unserer Umgebung viel mehr Computer die ohne ein OS auskommen und auf denen ein ganz spezielles Programmsystem läuft, welches eine ganz spezifische und eng begrenzte Funktion ausführt. Nehmen wir nur als Beispiel einen Schachcomputer: Die Hardware ist ähnlich strukturiert wie bei einem normalen Computer, und dennoch dient dieses Gerät dank seiner Programmierung nur einer einzigen Funktion, dem Schachspiel. Ein anderes Programm ist auf diesen Geräten nicht startbar – obgleich das ohne Probleme möglich wäre, sofern man statt dem Schachprogramm eine Art Betriebssystem installieren würde.

Ein Betriebssystem aber ist wesentlich universeller und es gibt verschiedene leicht unterschiedliche Definitionen was ein Betriebssystem genau ist. Allgemein kann man wohl sagen, dass ein Betriebssystem eine Software ist, um in universeller und variabler Weise die Funktionaltitäten eines Computers nutzen zu können. Dazu zählen Aufgaben, wie die Verwaltung von Funktionen und Daten in den verschiedensten Betriebsmitteln und Speicherformen, der Benutzerschnittstelle und anderer I/O-Geräte. Außerdem steuert es die Ausführung von Programmen in all ihren Facetten.

Letztlich muss unser einfaches Betriebssystem eine minimal Schnittstelle zu folgenden Funktionen realisieren:

  1. Textanzeige auf einem VGA-Monitor oder einem TV.
  2. Texteingabe über Tastatur.
  3. Zugriff auf Dateien auf SD-Card als Massenspeicher.
  4. Starten von Programmen.

Und auf diese Funktionen wollen wir uns auch anfänglich begrenzen. Im Prinzip braucht man nicht unbedingt ein Betriebssystem auf dem Hive. Als ich mit dem Aufbau des ersten Gerätes anfing, testete ich die ersten Funktionen einfach indem ich die entsprechende Software in dem RAM oder den EEProm des Hive-Prototypen speicherte. Das geht ganz super für erste Experimente und Testprogramme, aber auf Dauer ist es doch recht umständlich. Also musste etwas wie ein Kommandointerpreter her und die Möglichkeiten geschaffen werden, Parameter an die Kommandos zu übergeben. Weiterhin musste ich externe Kommandos vom Massenspeicher startbar machen und auch ihnen Parameter übergeben. Ein einfaches DOS also, wie man es schon auf den Homecomputern mit angeschlossenem Diskettenlaufwerk hatte.
Diese Kommandozeile aber ist auch nur ein normales Programm welches ein Bestandteil des eigentlichen Betriebssystems ist und durch dieses auf die Funktionen des Systems zugreifen kann. Diese Systemfunktionen werden als Schnittstelle allen Programmen zur Verfügung gestellt. Und genau diese Schnittstelle, das IOS,  ist der Kern des Systems.

Link: Wikipedia „Betriebssystem“

Teil 2 – Ein einfaches Hive-OS – Schritten für Schritt

Bellatrix-Code

„Am Anfang war nur Bellatrix und Bellatrix war genug.“

Der wirkliche Bau des Hive hat mit Bellatrix begonnen, weshalb wir uns an diesem Punkt vorerst auch auf diesen Chip konzentrieren wollen. Welche Funktion erfüllt Bellatrix in unserem SpinOS? Verdeutlichen wir uns das an einem Blockschaltbild. Wie man erkennen kann, konzentrieren wir uns vorerst auf das absolute Minimum.

Hinweis: Wenn jemand seinen Hive schon aufgebaut hat, ist es sinnvoll Regnatix und Administra vorerst zu deaktivieren, indem der Code „prop-disable.spin“ aus dem Archiv der Testprogramme in die EEProms geflasht wird. Damit kommen uns diese beiden Mikrocontroller bei den Experimenten nicht in die Quere.
Aber für unsere ersten Experimente wollen wir noch unverschämter sein, denn wir haben es bei den Propellerchips ja schließlich mit Mikrocontrollern zu tun! Worin besteht der Unterschied von einem Mikrocontroller zu einem Mikroprozessor? Ein Mikrocontroller enthält alle grundlegenden Bausteine eines Computers (CPU, RAM, ROM, Timer und I/O-Bausteine) auf einem Chip. Man kann mit ruhigem Gewissen sagen, dass es sich bei Mikrocontrollern also um „Ein-Chip-Computer“ handelt. Die vorhandenen Ressourcen sind sicher nicht so gewaltig wie bei einem modernen PC, aber so mancher Retrocomputer könnte durchaus locker in einem Propellerchip verschwinden. Im Vergleich mal die Platine (Quelle: http://atarinside.dyndns.org/ ) eines Atari 800 XL.

Wie wir sehen handelt es sich bei diesem Atari um ein Gerät, welches nicht mit einem Mikrocontroller arbeitet. Ein genauerer Vergleich und weitere Infos zum Propellerchip ist auf dieser Seite zu finden: „Tutorial: Build your OS – Der Propellerchip“. Dieser wunderbare 8Bit-Retro-Computer besitzt folgende technische Daten im Vergleich zu einem Propellerchip:

Atari 800 XL Propellerchip
CPU 1 x 8 Bit MOS6502C 8 x 32 Bit RISC
Taktfrequenz 1,79 MHz 80 MHz
RAM 64 KByte 48 KByte
ROM 24 KByte 32 KByte

Bei den I/O-Leitungen wird ein Vergleich schwierig, da man mit wenigen Widerständen sowohl einen VGA-Monitor, TV, Keyboard, Maus, Sound und ein SD-Cardlaufwerk an einen Propeller anschließen kann. Nun, es sollte uns genügen zu behaupten, dass sich beide Systeme in diesen Belangen ähnlich sind. Wie man nun unschwer erkennen kann, haben wir in einem Propellerchip mittlerweile ganz außergewöhnliche Ressourcen zur Verfügung – und das Ganze auf einem einzigen Chip mit einer fast lächerlichen Außenbeschaltung. Allerdings muss man auch beachten, dass bei diesem Vergleich jeder einzelne Spezialchip durch einen RISC-Core realsiert werden muss, wenn man etwas ähnliches realisieren möchte. Behält man nun noch im Hinterkopf, was alles mit diesem Atari möglich ist, wird sicher jedem schnell klar, welchen Spaß man schon mit nur einem Propellerchip haben kann – und drei solche Genies haben wir im Hive unter Vertrag genommen!

Und genau an diesem Punkt wollen wir ansetzen, denn wir ignorieren für eine kurze Zeit einfach mal Ragnatix und Administra, um uns ein wenig mit dem Propeller an sich anzufreunden. Eine Besonderheit des Hive-Designs ist ja die Verwendung von drei gleichartigen aber sehr flexiblen Schaltkreisen für die verschiedenen Aufgaben. Man muß also nicht lernen wie verschiedene sehr unterschiedliche Spezialprozessoren (Hauptprozessor, Grafik, I/O…) funktionieren, sondern wenn man versteht wie ein Propeller im Hive funktioniert, versteht man prinzipiell alle weiteren Funktionskomplexe.

Also vereinfachen wir für unsere ersten Experimente noch einmal unser Schema:

In diesem Schema gibt es weder Administra, noch Regnatix. Und es gibt diesem Umstand entsprechend auch noch keinen Bus zwischen den drei Damen. Wer Lust dazu verspürt, kann ruhig auch im Verlauf der Experimente eigene Programme für Bellatrix schreiben. Dies ist keine verlorene Liebesmüh, den solche Programme können später unter TriOS mit dem Kommando „bload“ problemlos geladen und genutzt werden, oder man erweitert sie mit Funktionen, wie man sein Verständnis der Hive-Struktur erweitert. Aber eines muß jetzt ganz klar sein: Selbst wenn wir jetzt Regnatix und Administra vergessen, haben wir mit Bellatrix schon einen kompletten minimalistischen Computer zur Verfügung:

  • Eingabe: Tastatur, Maus
  • Ausgabe: VGA-Monitor, TV
  • Massenspeicher: EEProm

Erste Lebenszeichen

Als erstes wollen wir uns nun dem VGA-Textbildschirm zuwenden. Als Basis habe ich ein fertiges VGA-Objekt für eine Auflösung von 1024 x 768 Pixeln verwendet. Mit diesem Treiber ist es möglich 24 Textzeilen mit je 64 Zeichen darzustellen. Zum VGA-Signal und zum Aufbau der Bildschirmdaten eines solchen Tile-basierten Treibers kommen wir später noch. Als erstes wollen wir das VGA-Objekt aktivieren, also in ein einfaches Testprogramm für Bellatrix einbinden und ein paar Zeichen ausgeben – das ist besser als alle Theorie.

CON                                     		'konstanten
  _clkmode = xtal1 + pll16x
  _xinfreq = 5_000_000

  cols = 64
  rows = 48
  tiles = cols * rows
  vga_basport = 8                                       'vga startport

OBJ                                                	'verwendete objekte
  vga     : "vga-treiber"      '3 cogs mit cursor

VAR                                                	'variablen
  long  col, row, color
  long  array[tiles/2]

PUB main                                            	'hauptroutine
  vga.start(vga_basport, @array, @vgacolors, 0, 0, 0)	'vga-objekt starten
  print_string(@text)                                  	'string ausgeben
  repeat

PRI print_string(ptr)                              	'stringausgabe
  repeat while byte[ptr]                               	'wiederhole bis $0
    print(byte[ptr++])                                	'ausgabe des zeichens

PRI print(c) | i, k                                   	'ausgabe eines zeichens
      k := color << 1 + c & 1
      i := $8000 + (c & $FE) << 6 + k
      array.word[row * cols + col] := i
      array.word[(row + 1) * cols + col] := i | $40
      ++col

DAT                                                   	'daten
vgacolors long                                        	'farbtabelle
  long $3C043C04       'lt grey on dk grey
  long $3C3C0404
  long $C000C000       'red
  long $C0C00000
  long $30003000       'green
  long $30300000
  long $0C000C00       'blue
  long $0C0C0000
  long $FC00FC00       'white
  long $FCFC0000
  long $FF80FF80       'red/white
  long $FFFF8080
  long $FF20FF20       'green/white
  long $FFFF2020
  long $FF28FF28       'cyan/white
  long $FFFF2828
  long $C0408080       'redbox
  long $3010F020       'greenbox
  long $3C142828       'cyanbox
  long $FC54A8A8       'greybox
  long $3C14FF28       'cyanbox+underscore
  long $F030C050       'graphics colors
text byte "Hallo, hier spricht Drohne235!",0

Sieht doch toll aus der Quelltext und ist wirklich nicht kompliziert! Also ran an die Tastatur, Propeller Tool starten und dieses Programm eintippen. Abschließend speichern wir das Ganze unter dem Namen „test-vga-1.spin“ in einem freien Verzeichnis. Zur Probe können wir die Datei mit F8 compilieren lassen und werden erstaunt eine Fehlermeldung zur Kenntnis nehmen, in welcher steht, dass eine ominöse Datei „vga-treiber.spin“ fehlt. Diese Datei enthält den eigentlichen Spin und Assemblercode für die Bildausgabe und wird in unser Testprogramm als Objekt eingebunden.

Downloadpaket für das Tutorial: Tutorial Buid your OS (326)

OBJ                                                	'verwendete objekte
  vga     : "vga-treiber"      '3 cogs mit cursor

Der Quelltext des VGA-Treibers ist zu umfangreich um ihn euch eintippen zu lassen, so gern ich das auch tun würde… 🙂 Deshalb liegt er dem Downloadpaket zu diesem Tutorial bei. Am besten ist es wohl unsere neue Datei „test-vga-1.spin“ auch in diesen Ordner zu kopieren und von dort neu zu öffnen. Nun sollte auch der Compiler mit F8 keine Probleme mehr haben. Am Anfang brauchen wir jetzt nur drei Funktionen aus dem Propeller Tool:

Fortsetzung des Tutorials: Build your OS – Der Bellatrix-Code – Seite 2