Ein 6809 Minimalsystem

Als der 6809 veröffentlicht wurde, war die Begeisterung groß, auch bei mir. Da ich mit dem Eurocom 1 ein 6802 (nicht 6502) System hatte, war ohnehin eine gewisse Nähe gegeben. Ich wollte unbedingt so ein System haben.

Allerdings waren sie in der Anfangszeit kaum zu bekommen und wenn doch, dann viel zu teuer. Als Student habe ich mir dann Anfang der 80er eine 6809 CPU gekauft und wollte damit ein System analog zum 6809 aufbauen. Allerdings hatte ich konkurrierend auch ein Z80 CP/M System aus Fertigplatinen aufgebaut und auch viel Software dazu, die ich für den 6809 nicht bekommen hätte (oder eben auch wieder viel zu teuer). Deshalb ist das Projekt eingeschlafen und hat mehr als 40 Jahre in der Bastelkiste geschlummert.

Anfang des Jahres ist mir die CPU beim Aufräumen wieder in die Finger gefallen und ich habe beschlossen, dieses Projekt endlich mal anzugehen. Nicht als dauerhaftes System, sondern als ein einfacher Breadboard Computer um mal ein wenig mit dem 6809 zu spielen.

Glücklicherweise ist das heute viel einfacher als vor 40 Jahren. Man muss nicht für jeden Versuch ein EPROM brennen und in das System einstecken. Ich habe einen Arduino Nano verwendet, der bei Bedarf die 6809 CPU in den Halt Zustand versetzt und dann direkt auf einen RAM Baustein zugreift. Das ganze System besteht (abgesehen vom Arduino) und aus der CPU, einem 32k RAM Baustein, einem Adressdekoder und einem Multiplexer. Dieser wurde notwendig, da der 6809 das E Signal, welches für den Speicherzugriff benötigt wird, im Halt Zustand nicht hochohmig macht. Der Arduino ist über eine serielle Verbindung mit dem PC verbunden auf dem ein spezielles Terminalprogramm läuft welches den RAM Bereich schreiben und lesen kann. Allerdings wäre der Zyklus Edit – Assemble – Upload – Test immer noch recht aufwändig wenn man die ersten Schritte auf einem neuen System macht. Der Test auf dem Breadboard wäre auch umständlich, da man kaum Logging- oder andere Ausgabemöglichkeiten hat.

Aus diesem Grund habe ich mir auch einen 6809 Simulator besorgt. Hier kann man die ersten Programme im Single Step oder mit Breakpoints ausprobieren, die Registerinhalte untersuchen oder Speicherbereiche anzeigen lassen. Wenn eine Funktion dann lief, habe ich sie auf den 6809 übertragen und geprüft, ob sie auf der realen Hardware auch noch korrekt ausgeführt wird.

Ich habe so ein rudimentäres Monitor System entwickelt, welches über eine Software-Interrupt Schnittstelle Funktionen wie Textausgabe, Texteingabe, Datei öffnen, lesen, schreiben und schließen zur Verfügung stellt. Kein komplettes Betriebssystem, aber mit zusätzlichen Aufwand hätte ich dorthin kommen können. Da es aber ohnehin kein dauerhaftes Projekt sein sollte, wollte ich auch die Zeit dafür in Grenzen halten.

Auch hier stellt sich die Frage: wohin führt das Projekt. Und wieder die Antwort: nirgendwo hin. Es macht mir Spaß, mal mit einem System zu arbeiten bei dem man jedes Bit unter Kontrolle hat und das man bis in den letzten Winkel verstanden hat. Aber im praktischen Einsatz ist es mir dann doch zu reduziert. Zudem – ich bin in der Z80 Assembler Welt groß geworden. Damit ist mir der extrem reduzierte Registersatz einfach zu wenig. Die Zero Page (oder Direct Page beim 6809) ist ein kleiner Trost, löst letztendlich aber eine Vielzahl von Memory read/ write Zugriffen aus. Beim 6809 kann man relativ gut mit lokalen Variablen auf dem Stack arbeiten, aber auch diese lösen Memory Zugriffe aus. Für seine Zeit war der 6809 sicherlich ein gutes System. Allerdings kam er viel zu spät – zu diesem Zeitpunkt waren die bereits die ersten 16 Bit CPUs auf den Sprung in den Massenmarkt – und er war leider auch nicht besonders schnell. Gut im Vergleich mit anderen 8 Bit CPUs aber deutlich langsamer als die 16 Bitter.

Mein Eurocom 1 lebt wieder

Meine ersten Kontakte zu einem Computer waren in einem VHS Kurs. Der Kursleiter hatte einen Nascom 1. Im Rahmen des Kurses wurden grundlegende Programmierkonzepte gezeigt und der Z80 Befehlssatz erklärt. Wenn man etwas Glück hatte, konnte man auch einmal ein Programm mit dem Hex Monitor eintippen.

Für mich als Schüler war der Nascom zum teuer, aber einen Eurocom 1 für 350 DM konnte ich mir leisten.

Das Netzteil musste selber zusammen gelötet werden, es kam als ein Bausatz. Die CPU Platine mit Hex Tastatur und 7-Segment Display kam fertig aufgebaut an.

In den kommenden Wochen habe ich das Handbuch x-mal durchgelesen. Zu diesem Zeitpunkt kam das Monitorprogramm noch mit einem ausführlich kommentierten Listening. Ich habe mich so intensiv damit beschäftigt, dass das Handbuch im Laufe der Zeit komplett auseinander gefallen ist und die Hex Tastatur so ausgeleiert war, dass man kaum noch damit arbeiten konnte.

So etwa 1980 hat mein Vater dann einen Nascom 2 als Familiencomputer angeschafft. Tatsächlich habe vorwiegend ich damit gearbeitet, mein nächst-jüngerer Bruder auch eine Zeit lang. Der Rest der Familie hat sich nicht so sehr dafür interessiert. Dieser Rechner mit ASCII Tastatur, Bildschirmausgabe und Basic war dann viel interessanter, der Eurocom 1 geriet in Vergessenheit. Das Netzteil habe ich für andere Projekte zweckentfremdet, die Eurocom 1 Platine aber zum Glück aufgehoben.

Sie lag in einer Bastelkiste bis sie mir vor ein paar Jahren mal wieder in den Sinn gekommen ist. Ich bin aber davon ausgegangen, dass nach über 40 Jahren die EPROMS keine Daten mehr enthalten und habe nichts weiter unternommen. In diesem Jahr habe ich ein 6809 Projekt gestartet, welches ich ähnlich wie den Eurocom 1 aufbauen wollte (es ist dann aber anders gekommen, ein richtiger Assembler ist schon angenehmer als eine Hex Eingabe von Maschinensprachbefehlen). Das hat dann den Anreiz gegeben, einen Versuch zu starten, den alten Computer wiederzubeleben.

Als erstes benötigte ich ein neues Netzteil. Der Eurocom 1 verwendet 2708 EPROMs, die brauchen 3 Versorgungsspannungen (+5V, +12V und -5V) und diese müssen auch in einer bestimmten Reihenfolge anliegen. Zum Glück gibt es im Handbuch einen Schaltplan zum Originalnetzteil und dort habe ich gesehen, dass sich Eltec nicht viele Sorgen um diese Reihenfolge gemacht hat. Es reicht offensichtlich, dass sie ungefähr gleichzeitig anliegen.

Interessanterweise habe ich in meiner Sammlung auch noch den alten Original-Trafo gefunden. Die -12V werden vermutlich nur für die RS 232 Schnittstelle benötigt, der Vollständigkeit halber habe ich aber alle 4 Spannungen, wie im Original, aufgebaut.

Nächster Schritt: Eurocom 1 Platine anschließen und sehen, ob er noch etwas sagt. Das war zuerst enttäuschend, das Display blieb dunkel. Aber ein wenig Rumdrücken auf der Platine hat gezeigt, dass es sich nur um einen Wackelkontakt handelt. Also auf alle Sockel etwas Kontaktreiniger gesprüht und anschließend die gesamte Platine mit Isopropanol gereinigt. Jetzt kam zumindest schon mal die „Eurocon Control“ Meldung (ein m ist mit einem 7 Segment Display nicht darstellbar).

Weiter ging es mit der Tastatur. Sie ist ein den 40 Jahren nicht besser geworden. Viele Tasten hatten gar keine Funktion mehr und die verbleibenden haben so stark geprellt, dass man sie auch nicht mehr verwenden konnte. Zudem hat sich die Kombination von Kleber und Hautfett über die Jahre zu einer dunklen Masse entwickelt. Mein erster Plan war, die Tasten gegen neue zu ersetzen. Allerdings hatte ich keine mit einem identischen foot print. Also mussten die vorhandenen wieder Instand gesetzt werden.

Zum Glück konnte man die Tasten relativ leicht öffnen. Der Kontakt war ein einfacher Neusilber-Draht und eine winzige Tellerfeder. Beides konnte ich mit etwas Geduld wieder reinigen und die Tasten wieder zusammensetzen. Das größte Problem bestand darin, die noch winzigere Feder richtig zu platzieren ohne, dass sie wegspringt. Eine ist entkommen, jetzt ist die Taste „Y“ ohne Funktion.

Die alte Beschriftung war einfach eine Folie mit Laser-Drucker Beschriftung. Diese habe ich entfernt, die Tastenkappen gereinigt und eine neue Beschriftung ausgedruckt.

Wie geht es weiter: ich fürchte – erst mal gar nicht. So viel Spaß die Erinnerung an alte Zeiten bringt, ich möchte so reduziert nicht mehr arbeiten. Der Eurocom 1 wird wieder in einer Bastelkiste verschwinden – diesmal aber mit Netzteil – und darauf warten, dass ich irgendwann doch wieder Lust darauf bekomme.

Ein einfacher Slider für HTML Seiten

Da ich auf meiner Hauptseite viele Bilder in Galerieform habe, bin ich mit dem Standard-Slider unzufrieden. Er ist nicht einfach zu bedienen und zeigt die Bilder nicht leicht durchblätterbar und in voller Bildschirmgröße an. Ich habe mir deshalb mal einige Slider aus dem Internet angesehen und habe nicht das richtige gefunden. Zum einen arbeiten einige Slider nicht sauber mit dem Firefox Browser zusammen. Insbesondere die reinen CSS Slider machen so viele Verrenkungen, dass es mich nicht wundert, das es an allen Ecken und Kanten hakt. Ich denke, dass einige Web Entwickler nur noch auf Chrome testen. Zum anderen muss man bei fast allen Slidern die html Seite anpassen. Ich habe keinen generischen Slider gesehen, der über Parameter gesteuert werden kann.

Im Nachhinein muss ich erkennen, dass ich länger nach einem brauchbaren Slider gesucht habe als die Eigenentwicklung Zeit gekostet hat. Wichtig für mich war, dass der Slider die Bilder aus dem WordPress Media Pool anzeigen kann, er sollte nicht für jede Galerie eine eigene Web Seite benötigen und er sollte per Maus und Tastatur gesteuert werden können. Und das Wichtigste: er sollte die Bilder in voller Größe anzeigen. Ein reiner CSS Slider war für mich hingegen nicht erstrebenswert. Wegen der Parametrisierbarkeit benötige ich ohnehin JavaScript. Ein einfacher CSS Aufbau hingegen ist ein echter Vorteil.

Das komplette Projekt besteht nur aus einer Datei, sie kann von meinem Github Repository herunter geladen werden: https://github.com/Matthias-Thiele/HTML-Image-Slider

Der Grundgedanke beruht wie bei vielen Slidern darauf, dass die Bilder übereinander gestapelt werden und immer nur ein Bild angezeigt wird. Das kann man über CSS leicht mit „display: none;“ steuern. Der Image Bereich ist bei mir zum Start leer, er wird beim Aufruf der Seite aus der Parameterliste heraus gefüllt.

          <div id="imagelist">
          </div>

Der JavaScript Code dazu ist überschaubar. Die Bilder können entweder durchnummeriert kommen oder mit einem beschreibenden Namen. Es wird ein IMG Element erzeugt, der Pfad zum Bild eingefügt und das Element in die imagelist eingehangen.

for (var i = imgStart; i <= imgEnd; i++) {
        var img = document.createElement("img");
        var imgSrc;

        if (descriptionName) {
            imgSrc = this.startPath + imgName + this.description[i] + "." + imgExt;
        } else {
            var num = (i < 10) ? (pendingZero + i) : i;
            imgSrc = this.startPath + imgName + num + "." + imgExt;
        }

        img.src = imgSrc;
        if (i === imgStart) {
            img.className = "active";
        }
        listRoot.appendChild(img);
        this.items.push(img);
    }

Die Statuszeile überlagert halb-transparent den unteren Bildteil. Vielleicht erweitere ich es später mal so, dass man sie auch ausblenden kann. In den meisten Fällen wird sie aber nicht stören.

          <nav class="slider-nav">
              <button class="previous" data-key="true" style="width:52%; text-align: right">
              <span>
                  <i>&lt;</i>
              </span>
            </button>
            <button class="next" data-key="false" style="text-align: left">
              <span>
                <i>&gt;</i>
              </span>
            </button>
              <span id="counter" style="float:right; width: 100pt; padding: 2pt;">1/6</span>
          </nav>
        </div>

Die Bild-Weiterschaltung läuft im Kreis. Wenn man am letzten Bild angekommen wird, wird als nächstes das erste Bild angezeigt und umgekehrt. Damit man die Orientierung nicht verliert und X-mal im Kreis läuft, wird in der Statuszeile angezeigt, wie viele Bilder es gibt und auf welchem Bild man gerade steht.

            Slider.prototype.advance = function(leftRight) {
                this.items[this.count].classList.remove('active');
                this.count += (leftRight) ? -1 : 1;
                
                if (this.count < 0) {
                    this.count = this.items.length -1;
                } else if (this.count >= this.items.length) {
                    this.count = 0;
                }
                
                this.items[this.count].classList.add('active');
                this.updateView();
            };
            
            Slider.prototype.updateView = function() {    
                var status = document.getElementById("counter");
                status.innerText = " " + (this.count + 1) + " / " + this.items.length; 
                
                var desc = document.getElementById("description");
                if (this.count >= this.description.lengt || !this.description[this.count]) {
                    desc.style = "display: none";
                } else {
                    desc.innerText = this.description[this.count];
                    desc.style = "display: inline-block";
                }
            };

Die Tastatursteuerung ist einfach. Es gibt nur zwei Kommandos – vorwärts und zurück. Diese können über Pfeil links/ rechts und über Bild hoch/ runter ausgelöst werden.

            Slider.prototype.keyPress = function(event) {
                event = event || window.event;
                var slider = document.querySelector('.next').slider;
                var keyCode = event.keyCode;
                
                if (keyCode === 33 || keyCode === 37) {
                  slider.advance(true);
                } else if (keyCode === 34 || keyCode === 39) {
                  slider.advance(false);
                }
            };

Die HTML Datei enthält keine Informationen zu den Bildern. Diese wird beim Aufruf der Seite über Parameter mitgegeben. Somit kann man die Seite irgendwo hinterlegen und aus beliebigen Anwendungen heraus aufrufen. Innerhalb der Web Seite kann man optional den Start des Pfades der Quelle hinterlegen. Damit kann man erzwingen, dass ein bestimmter Bereich nicht einfach verlassen werden kann und zusätzlich ist dann der Parametersatz etwas kürzer, da dieser Teil nicht jedes mal mit angegeben werden muss.

            var slider = new Slider("imagelist", "https://mmth.de/wp-content/uploads/");

Der erste Parameter gibt die id des DIV Elements an welches die Imageliste enthalten soll und der zweite Parameter den Start der URL jedes Bildes. Man kann diesen auch auf einen Leerstring setzen (nicht einfach weglassen).

http://localhost:8080/SliderTest/slider.html?name=2023/09/&ext=jpg&desc=Mainau1~Mainau2~Mainau3~Mainau5

Folgende Parameter gibt es:

nameEnthält den festen Namensanteil des Bildes. Bei durchnummerierten Bildern wird die Nummer am Ende automatisch angefügt. Falls der Startpfad aus der html Datei noch um Unterverzeichnisse ergänzt werden muss, kommen diese hier vor den Namen. Bei Bildern deren Name aus der Beschreibung generiert wird, kann man hier den Verzeichnispfad hinterlegen.name=Mainau
name=2023/Mainau
startBei durchnummerierten Bilder wird hier die Nummer des ersten Bilds angegeben. Im Normalfall wird das 1 sein, das muss aber nicht zwingend so sein. Wenn man nur eine Teilsequenz anzeigen möchte, kann man hier auch eine höhere Zahl angeben.
Falls die Bilder nicht Bild1, Bild2, .., Bild9, Bild10 durchnummeriert sind, sondern mit fester Nummernbreite Bild01, Bild 02, .., Bild09, Bild10 bezeichnet wurden, muss man beim Startwert auch eine führende 0 einfügen: start=01
start=1
endHier wird die Nummer des letzten Bildes eingetragenend=5
extAlle Bilddateien müssen vom gleichen Typ sein, da man nur eine Extension (ohne Punkt) angeben kann. Der Name setzt sich dann aus Startpfad + Name + Nummer + Punkt + Extension zusammen.ext=jpg
descBei durchnummerierten Bildern ist der Beschreibungsteil optional. Wenn er vorhanden ist, wird die Beschreibung zu jedem Bild oben links eingeblendet. Bei Bilddateinamen aus der Beschreibung muss dieser Parameter eine Liste aller Namen der Bilddateien enthalten.desc=Haus~Auto~Boot

Test eines einfachen Ultraschall Sensors für 80 Cent

In diesem Video teste ich einen einfachen Ultraschallsensor, der bei Aliexpress gerade mal 80 Cent kostet. Die Ansteuerung ist sehr einfach und schnell (wenn man keine unnötigen Fehler macht) und die Ergebnisse sind erstaunlich gut.

#include <Arduino.h>

const int TRIG_PIN = 12;
const int ECHO_PIN = 13;
const int ITEM_COUNT = 50;

long simpleMultiMeasure();

void setup() {
  Serial.begin(9600);
  pinMode(TRIG_PIN,OUTPUT);
  digitalWrite(TRIG_PIN, LOW);

  pinMode(ECHO_PIN,INPUT);
}

void loop() {
  long duration = simpleMultiMeasure();
  long distanceMm;
 
  // convert the time into a distance
  distanceMm = duration * 100l / 582l;
 
  if (distanceMm <= 0)
  {
    Serial.println("Out of range");
  }
  else 
  {
    Serial.print(duration);
    Serial.print(" ticks, ");
    Serial.print(distanceMm);
    Serial.print(" mm");
    Serial.println();
  }
  
  delay(500);
}

long simpleMultiMeasure() {
  long sum = 0;

  for (int i = 0; i < ITEM_COUNT; i++) {
    digitalWrite(TRIG_PIN, HIGH);
    delayMicroseconds(20);
    digitalWrite(TRIG_PIN, LOW);
    sum += pulseIn(ECHO_PIN,HIGH);
    delayMicroseconds(20000);
  }

  return sum / ITEM_COUNT;
}


Ein RISC-V Test mit dem Sipeed Longan Nano Board

Ich wollte schon lange mal mit einem RISC-V Prozessor experimentieren. Mit dem Longan Nano Board für 2,50 Euro steht in Development Board zur Verfügung bei dem man nicht lange nachdenken muss. Für ein Euro Aufpreis bekommt man noch ein farbiges LCD dazu.

Falls jemand an dem winzigen Assembler Programm aus dem Video interessiert ist, kann man es hier kopieren:

.section .text
.align 2
.global toggle

.equ GPIO_PORT_B_CONTROL, 0x40010c10
.equ SET_ALL_BITS, 0x0000ffff
.equ RESET_ALL_BITS, 0xffff0000


toggle:
  li t0, GPIO_PORT_B_CONTROL
  li t1, SET_ALL_BITS
  li t2, RESET_ALL_BITS

loop:
  sw t1, (t0)
  sw t2, (t0)
  sw t1, (t0)
  sw t2, (t0)
  j loop

Startbild: RISC V prototype chip – crop of File:Yunsup Lee holding RISC V prototype chip.jpg. Wikimedia, Creative-Commons-Lizenz „CC0 1.0 Verzicht auf das Copyright“

Ein computergesteuerter Messplatz mit einem ESP 32, Teil 2

In diesem zweiten Teil wird die Software zu dem Projekt beschrieben. Sie besteht aus drei Teilen.

  1. Ein Platform IO Projekt mit einem C++ Programm welches auf dem ESP32 läuft.
  2. Ein Netbeans Projekt in Java welches auf dem PC ein Framework zur Verwendung des Messplatzes zur Verfügung stellt. Weiterhin enthält es einen komfortablen Weg zur Erstellung von CSV (comma separated values) Dateien.
  3. Ein Netbeans Projekt welches die Verwendung der DataIO jar Datei zeigt.

Ein computergesteuerter Messplatz mit einem ESP 32, Teil 1

Wenn man umfangreiche Messreihen aufnehmen will, ist es kaum manuell durchführbar. Ich verwende einen ESP 32 und verschiedene I2C Module für diese Aufgabe. Der Messplatz verfügt über 4 Analogeingänge mit 15 Bit Auflösung, 4 Analogausgänge mit 12 Bit Auflösung und 32 Digital Ein- und Ausgänge.


Der erste Teil beschreibt die Hardware. In einem kommenden zweiten Teil wird die Software dazu gezeigt.

Vintage Computer der 70er und 80er Jahre

In diesem Video zeige ich die Computer mit denen ich in den 70er und 80er Jahren gearbeitet habe. Da ich zu alt für ZX80 und C64 bin, tauchen hier weniger bekannte Namen wie Eurocom 1 und Nascom 2 auf. Es endet mit dem Atari 520ST, den ich bis in die späten 80er verwendet habe.

Eine 1 Bit ALU aus Relais – Teil 1 bis 3

Ich wollte schon längere Zeit mal eine Schaltung aus Relais aufbauen. Im Internet gibt es viele Beispiele für unterschiedlich komplexe Projekte bis hin zu einer kompletten CPU.

So weit wollte ich nicht gehen, ich bin mit der ALU (der zentralen Recheneinheit) zufrieden. Und die ALU ist auch nur 1 Bit breit. Aber sie kann Addieren (mit Carry) und die logischen Operationen AND, OR und XOR ausführen. Ein externer Sequencer, der die ALU verwendet könnte mit zusätzlicher Logig weiterhin eine Subtraktion, Negation oder Inversbildung durchführen.

 

Aus den Funktionen der 1 Bit ALU lassen sich dann komplexere Funktionen aufbauen: 16 AND, OR, XOR und ADD sowie zusätzlich SUB (aus XOR und ADD) sowie MUL (aus ADD).

Die Steuereinheit wird nicht aus Relais aufgebaut – hier wird ein Arduino Nano eingesetzt.

Und zum Schluss noch ein Z8000 Simulator welcher die ALU für seine Rechenoperationen verwendet.