Geekly articles weekly

Meine kleinen Staffeln: Triple Brainfuck oder What Is Madness


Abb. 1: BrainfuckPC-Relay-Computer im Hintergrund des Autors

Ich setze die glorreiche Tradition der jährlichen Zusammenfassung meiner verrücktesten Computerprojekte fort und präsentiere Ihnen den dritten und letzten Artikel über das BrainfuckPC-Relay-Computerprojekt.

In früheren Serien:


Nach zehn Jahren des Träumens und Nachdenkens, mehr als zwei Jahren ruhiger Arbeit und Montage kann ich mit Zuversicht sagen, dass das Relais-Computer-Projekt stattgefunden hat. Trotz der Tatsache, dass der Computer aus praktischer Sicht unbrauchbar ist und auch regelmäßig abstürzt, ist er zum Ausgangspunkt für die nächsten, nicht weniger verrückten Cyberprojekte geworden.

Unter dem Cutter klingeln Relaisblöcke, die weltweit schnellsten Relaisberechnungen, Nachbearbeitungen, Vakuumanzeigen und vieles mehr.

Brainfuck Programmiersprache


Die Brainfuck-Programmiersprache ist vielleicht die beliebteste esoterische Programmiersprache der Welt. Gleichzeitig ist das echte Turing ein kompletter Sumpf . Nur 8 Anweisungen, auf die Sie alles schreiben können, aber für eine sehr lange Zeit.
Zum Beispiel habe ich drei Tage gebraucht, um das Teilungsprogramm 355/113 zu schreiben und zu debuggen, das 6 Dezimalstellen auf dem Terminal druckt.

Abbildung 2: Anweisungen für die Brainfuck-Sprache

Die gesamte Syntax der Sprache basiert auf RAM für 30.000 Speicherzellen mit einer Kapazität von 8 Bit.

  • Mit zwei + und - Anweisungen ändern wir den Wert in der aktuellen Datenzelle um eins nach oben oder unten.
  • Mit zwei Anweisungen < und > ändern wir den Zeiger auf die aktuelle Datenzelle um eins und bewegen uns dabei nach links oder rechts durch den Speicher.
  • Zwei weitere Anweisungen [ und ] - ermöglichen es uns, Schleifen zu organisieren. Alles in den Klammern ist der Körper der Schleife. Verschachtelte Schleifen erlaubt. Die Logik des Befehls ist einfach - wenn der Wert der aktuellen Datenzelle nicht gleich Null ist - führen wir eine Iteration der Schleife durch. Wenn sie gleich ist, verlassen wir die Schleife.
  • Die letzten beiden Anweisungen . und - ermöglichen es Ihnen, den Wert der aktuellen Zelle in der Konsole anzuzeigen oder deren RAM einzugeben. Dadurch wird Interaktivität erreicht.

Ja, das ist mehr als genug, um ein Programm zu schreiben. Die Existenz von C-Compilern in Brainfuck scheint darauf hinzudeuten. Die Dichte des Codes ist jedoch nicht vorhanden. Um einfache Operationen auszuführen, z. B. das Hinzufügen der Werte von zwei Speicherzellen, müssen Sie Hunderte von Brainfuck-Anweisungen ausführen.

Brainfuck ++


Versuchen wir, die Dichte des Codes zumindest ein wenig zu erhöhen. Wenn Sie Programme studieren, die in dieser Sprache geschrieben sind, können Sie darauf achten, dass sie größtenteils aus Sequenzen derselben Anweisungen + - <> bestehen . Dies führt viele zu der Idee, die Abfolge solcher Anweisungen zu einer zusammenzufalten und eine kleine Produktivitätssteigerung zu erzielen, die von Programm zu Programm bis zu zehn Prozent betragen kann, und eine mehrfache Geschwindigkeitssteigerung zu erzielen. Zum Beispiel ersetzen wir 10 Inkrementoperationen durch eine +10 Operation. 20 Operationen zum Bewegen des Zeigers nach rechts auf die Operation> 20 und so weiter.


Abbildung 3: Anweisungen für die Sprache brainfuck ++

Von der Theorie zur Praxis


Wie Sie verstehen, kann man die Operation Rb = Ra + Rb nicht einfach in die Brainfuck-Sprache aufnehmen und schreiben, wobei Ra und Rb Speicherzellen sind. Wir können nur den Inhalt einer Zelle in eine Konstante ändern und prüfen, ob sie Null ist. Um die beiden Zahlen zu addieren, müssen wir nur noch +1 für die Rb-Zelle und -1 für die Ra-Zelle tun, bis der Inhalt der Ra-Zelle Null wird. Wir schreiben dies in Form eines Codes in C:

/*(mem+RbPos) += *mem */ void addMov(Memory &mem, uint16_t RbPos) { while (*mem) { mem += RbPos; (*mem)++; mem -= RbPos; (*mem)--; } }

Infolgedessen wird der alte Wert in der RbPos-Zelle plus dem Wert an der Quelladresse angezeigt. Klasse Speicher - ein Container mit 65k Ganzzahlzellen. Die Haupteigenschaft besteht darin, dass beim Überlaufen des Zeigerwerts der Wert an den Anfang des Arrays zurückgegeben wird. Wie in meiner echten Hardware.

Der Nachteil der beschriebenen Funktion ist der Verlust des ursprünglichen Wertes - er wird auf Null zurückgesetzt. Fügen Sie eine weitere Rc-Variable hinzu, um sie zu speichern:

 /* *(mem+RcPos) = *mem *(mem+RbPos) += *mem */ void addCpy(Memory &mem, uint16_t RbPos, uint16_t RcPos) { while (*mem) { mem += RbPos; (*mem)++; mem -= RbPos; (*mem)--; mem += RcPos; (*mem)++; mem -= RcPos; } }

Infolgedessen liegt der kopierte Term in der RcPos-Zelle. Nun, für den Fall, dass es früher Null gab.

Da die von mir verwendete Notation sehr ähnlich zu brainfuck ++ ist, schreiben wir unsere Funktion einfach in bfpp-Zeichen um, wobei wir RbPos für 4 und RcPos für 5 als Beispiel nehmen:

[
>>>>
+
<<<<
-
>>>>>
+
<<<<<
]

Nachdem Sie alle Grundelemente beschrieben haben, können Sie sie zu komplexeren Strukturen kombinieren und das Programm mit den erforderlichen Funktionen abrufen. Als Ergebnis können Sie ein Programm erhalten, das 355 durch 113 teilt (oder beliebige andere Zahlen innerhalb von 16 Bit übereinander).

Gleitkommaprogramm
 class Memory { public: Memory() { memset(m_mem, 0, sizeof(m_mem)); memPtr = 0; } Memory& operator += (uint16_t ptr) { memPtr += ptr; return *this; } Memory& operator -= (uint16_t ptr) { memPtr -= ptr; return *this; } uint16_t& operator [] (uint16_t ptr) { return this->m_mem[ptr]; } Memory& operator = (uint16_t ptr) { memPtr = ptr; return *this; } uint16_t & operator * () { return m_mem[memPtr]; } Memory& operator ++ () { memPtr++; return *this; } Memory& operator -- () { memPtr--; return *this; } private: uint16_t memPtr; uint16_t m_mem[65536]; }; void calcPi() { Memory mem; *mem = 22; mem += 1; *mem = 7; while (*mem) { mem += 1; (*mem)++; mem -= 1; (*mem)--; mem += 2; (*mem)++; mem -= 2; }//correct -909 while (*mem) { (*mem)--; } mem -= 1; while (*mem) { mem += 2; while (*mem) { mem += 4; (*mem)++; mem -= 4; (*mem)--; } mem += 4; while (*mem) { (*mem)--; mem -= 4; (*mem)++; mem -= 2; (*mem)--; if (!*mem) { //JZ out goto out; } mem += 6; } mem -= 6; out: mem += 6; if (*mem) { while (*mem) { mem -= 6; (*mem)++; mem += 6; (*mem)--; } mem -= 6; if (*mem) goto out1; } mem -= 5; (*mem)++; mem -= 1; } out1: mem += 10; *mem += 0x50;//P putc(*mem, stderr); *mem += 0x19;//i putc(*mem, stderr); *mem -= 0x2C;//= putc(*mem, stderr); mem -= 9; *mem += 0x30; putc(*mem, stderr); mem += 9; *mem -= 0xf; putc(*mem, stderr); mem -= 10; *mem += 6; while (*mem) { (*mem)--; mem += 1;//mem == 1 //nullCell(mem); while (*mem) { (*mem)--; } mem += 1; //mulConst(mem, 1, 10); while (*mem) { (*mem)--; mem -= 1; (*mem) += 10; mem += 1; } mem += 1; //addCpy(mem, 1, 2); while (*mem) { mem += 1; (*mem)++; mem -= 1; (*mem)--; mem += 2; (*mem)++; mem -= 2; } mem += 3; //nullCell(mem); while (*mem) { (*mem)--; } mem -= 5; while (*mem) { mem += 4; while (*mem) { mem += 6; (*mem)++; mem -= 6; (*mem)--; } mem += 6; while (*mem) { (*mem)--; mem -= 6; (*mem)++; mem -= 4; (*mem)--; if (!*mem)//,  ,      { goto out2; } mem += 10; } mem -= 10; out2: mem += 10; if (*mem) { //addMov(mem, -(6+ 4)); while (*mem) { mem -= 10; (*mem)++; mem += 10; (*mem)--; } mem -= 10; if (*mem) goto out3; } mem -= 5; (*mem)++; mem -= 5; } out3: mem += 4; while (*mem) { mem -= 3; (*mem)++; mem += 3; (*mem)--; } mem += 1;//mem == 6 *mem += 0x30; putc(*mem, stderr); mem += 1;//mem == 7 while (*mem) { (*mem)--; } mem -= 3; while (*mem) { mem -= 1; (*mem)++; mem += 1; (*mem)--; } mem -= 4;// mem == 0 } *mem += 0x0a; putc(*mem, stderr); *mem += 3; putc(*mem, stderr); }


Relais-Computerarchitektur


Das zentrale Element des Relaisprozessors ist ein 16-Bit-Volladdierer mit parallelem Übertrag. Am Eingang sind zwei Register angeschlossen. TMP ist das temporäre Register, in dem der alte Wert abgelegt wird, und CMD ist das Befehlsregister, in dem der Befehl und die Konstante gespeichert werden, um die der alte Wert geändert wird.

Daher kann ich optimierte Brainfuck ++ - Operationen ausführen und gleichzeitig vollständige bedingte Sprünge erhalten - Jump If Zero und Jump If Not Zero zu jeder Seite des Programms.

Das Ergebnis der Summierungsoperation kann entweder in eines der Kontextregister - AP - mit der Nummer der aktuellen Datenzelle oder IP - mit der Nummer des aktuellen Befehls hochgeladen werden. Außerdem kann das Ergebnis in die aktuelle RAM-Zelle hochgeladen werden, wenn es um Anweisungen + und - geht.


Abb. 4: Relais-Computerarchitektur in Betrieb. Die Phase des Ladens der neuen Anweisung wird durch die Phase ihrer Ausführung ersetzt.

Zunächst müssen wir die Nummer des nächsten Befehls berechnen - d. H. Führen Sie eine IP ++ - Operation aus. Dazu wird einer zum alten Wert des IP-Registers addiert, das Ergebnis in das IP-Register zurückgeschrieben und der nächste Befehl an dieser neuen Adresse in das CMD-Register geladen.

Der zweite Schritt ist die Ausführung des neu geladenen Befehls. Wenn es mit dem Addierer funktioniert, ähnelt der Prozess seiner Ausführung dem Prozess des Ladens eines neuen Befehls - der alte Wert befindet sich im temporären Register, wir addieren die in den unteren Bits des CMD-Registers liegende Konstante und schreiben das Ergebnis zurück in das Register oder die aktuelle Datenzelle.
Somit wird der Befehl in einem Tick des Taktgenerators ausgeführt. An einer fallenden Front laden wir die nächste Anweisung, an einer zunehmenden - wir führen sie aus.

kein Bug, sondern eine Funktion
Und hier wurde ein Merkmal enthüllt. Nach dem Einschalten des Computers wird die erste Vorderseite des Taktgenerators vergrößert, und daher gibt es - wir müssen den aktuellen Befehl ausführen, den noch niemand in das CMD-Register geladen hat - Nullen.

Folgen Sie den leeren Anweisungen und ... machen Sie IP ++!

Infolgedessen enthält die Nullspeicherzelle des Programms Null und wird niemals ausgeführt. Der erste aus dem Speicher geladene Befehl ist der Befehl bei 0x0001.

Befehlssatz



Abb. 5: Befehlssatz des Relaiscomputers

Die Befehle sind 16-Bit, wobei die 4 höherwertigen Bits für die Art des Befehls verantwortlich sind und die niederwertigen 12 Bits die Nutzlast sind. In den meisten Fällen ist dies eine Konstante.

  • NOP-Anweisung - ignoriert.
  • Der CTRLIO-Befehl ist ein spezieller Befehl, dessen Verhalten von der Nutzlast-Bitmaske codiert wird. Zunächst werden Befehle implementiert, um in die Konsole zu schreiben und von der Konsole zu lesen (im synchronen oder asynchronen Modus). Zweitens können Sie den 16-Bit- oder 8-Bit-Betriebsmodus der Maschine einstellen. Und drittens können Sie mit der Anweisung CTRLIO.HALT die Maschine stoppen. Das Lustige ist, dass Maskenbits
    nicht blockierend. Sie können sie mindestens alle gleichzeitig einstellen, aber das Verhalten der Maschine ist undefiniert.
  • Der ADD-Befehl ist eine Datenzellenoperation. Ändert den Wert in der Zelle um den Wert der Konstante. In diesem Fall ist Bit 12 ein vorzeichenbehaftetes Bit und wird in die Bits 13-15 kopiert. Daher wird aus dem Befehl 0x2ffe die Operation * AP + = 0x0ffe und aus dem Befehl 0x3ffe * AP + = 0xfffe. Die Subtraktionsoperation wird durch Addition durch eine negative Zahl ersetzt.
  • ADA-Anweisung - implementiert die Operation AP + = const und ermöglicht Ihnen das Navigieren durch den Speicher.
  • Anweisungen JZ und JNZ sind bedingt. Abhängig von der Z-Flagge können Sie entweder einige Anweisungen vorwärts oder rückwärts springen oder an Ort und Stelle bleiben. Abhängig von der Betriebsart der Maschine - 16 oder 8 Bit - wird der Zustand des Z-Flags entweder durch das niedrigstwertige Datenbyte oder durch das gesamte Wort bestimmt.

Technische Eigenschaften


BrainfuckPC ist ein 16-Bit-Computer mit einem Reed-Relay-Prozessor, einer Von Neumann-Architektur und einem Brainfuck ++ - Befehlssatz

  • Gesamtzahl der Relais: 578 Stück
  • Die Gesamtzahl der Logikelemente: 157 Stück
  • Adressbusbreite: 16 Bit
  • Adressierung: Wort für Wort
  • RAM: 128 KB (64 KB)
  • Datenbusbreite: 16 Bit / 8 Bit
  • Taktfrequenz (Strom / Maximum): 25Hz / 40Hz
  • Leistungsaufnahme: 70W
  • Gesamtabmessungen: 110kh650kh140mm
  • Gewicht: 15 kg


Anfangs wurde angenommen, dass der Computer mit Frequenzen bis zu 100 Hz arbeiten wird ... Und dies - für eine Minute - 4 Klavieroktaven. Leider haben die ersten Tests gezeigt, dass 40 Hz die Obergrenze sind, aber es gibt viel davon für die Relaisschaltung. Dies gilt umso mehr, wenn eine externe Taktung erforderlich ist, um zwei Impulse pro Zyklus anzulegen - aufgrund der Besonderheiten der Synchronisationsschaltung mit einem externen Signal. 80Hz für Musik ist schon etwas.

Computerkomposition



Abb. 6: Hauptkomponenten des Relaiscomputers.

Schauen wir uns den Computer genauer an. Fast das gesamte Volumen der Maschine wird von Relaisprozessoreinheiten belegt. Im Moment passt alles in fünf Blöcke, aber es gibt Platz für sechs - wenn Sie also wirklich wollen, können Sie später die Funktionalität des Prozessors erweitern.
Jeder solche Block enthält 32 Module, in jedem Modul befinden sich 3 oder 4 Reed-Relais RES55 und RES64. Die Stromversorgung jeder Einheit beträgt 5 V, 3 A.


Abb. 7: Eine Reihe von Blöcken und Modulen eines Relaisprozessors, die zur Installation auf einem Rahmen bereit sind.

Jedes Modul ist einheitlich. 60x44mm, 16-poliger Stecker. Beim Zusammenbau der Logikblöcke habe ich das gewünschte Modul in einen freien Steckplatz gesteckt und die Verbindungen geflasht.


Abb. 8: D-Flip-Flop-Module werden auf Funktionsfähigkeit überprüft.

Zentrale Reihe - Addiererblöcke und Registerblöcke. Über und unter ihnen befinden sich 16-Bit-Latches basierend auf RES43, die den Datenfluss zwischen den Blöcken umschalten. Alle Daten drehen sich hier.

Die untere Reihe ist die Reihe der Prozessorlogikblöcke. Jetzt sind zwei Blöcke teilweise gefüllt, aber wenn Sie es wirklich wollen, ist das Ändern und Erweitern der Funktionalität aufgrund des freien Speicherplatzes mehr als möglich.


Abb. 9: Der Rahmen wird aus 2 mm Aluminiumblech unter Laserschneiden zusammengesetzt. Auf dem Foto - bereits geschweißter und grundierter Rahmen, fertig zum Lackieren.

Der obere Teil ist Indikator. Links befindet sich der Maschinenstatusblock - Anzeigen basierend auf dem IV-6 zeigen die Nummer der aktuellen Speicherzelle und die Nacht des aktuellen Befehls, den Befehl selbst und den allgemeinen Zähler der ausgeführten Befehle an. Letzteres ist sehr nützlich, denn wenn der Emulator beispielsweise sagt, dass Sie bis zum ersten Zeichen in der Konsole 30.000 Anweisungen ausführen müssen, zeigt der Zähler deutlich an, wo sich die Maschine jetzt befindet und wann die Zählung beendet ist.


Abb. 10: Die endgültige Ansicht des Anzeigebereichs. Im Herstellungsprozess.

Auf der rechten Seite befindet sich die Speicherkarte - das umstrittenste Element der Maschine. Obwohl ich glaube, dass der Computer immer noch Relais ist, ist der Prozessor definitiv 100% Relais. Die Peripherie ist moderner. Insbesondere ist RAM ein statischer Speicherchip. Aber fast alle modernen Hersteller von Relay-Computern auch.


Abb. 11: Programmierer. 16 Adressleitungen, 16 Datenleitungen, Strom-, Erdungs- und Schreibleseleitungen. Insgesamt 36 Kontakte.

Da der Speicher von Programmen und Daten gemeinsam genutzt wird, muss jedes Mal, wenn Sie den Computer einschalten, jemand oder etwas das Programm in den Arbeitsspeicher laden. Diese Aufgabe ist dem Programmierer zugeordnet. Im Moment befindet sich der Programmierer auf der Speicherkarte selbst. Jetzt hat er genau zwei Aufgaben.

  1. Laden Sie das Programm im RAM herunter, da jedes Mal, wenn Sie die Stromversorgung manuell mit den Kippschaltern einschalten, eine leichte Faulheit vorliegt, obwohl diese Möglichkeit besteht.
  2. Überwachen Sie den Status eines bestimmten Speicherbereichs und zeigen Sie ihn auf einer 32x16-LED-Matrix an.

Dies hat keine Auswirkungen auf den Prozessor. Beim Debuggen ist es sehr nützlich, in Echtzeit zu sehen, was im RAM geschieht. Wenn der Programmierer extern ist, dient das LED-Panel anschließend einem der Anzeigemodule. Er kennt die Adresse bereits, es bleibt ihm die Eingabedaten zu geben.


Abb. 12: Blockschaltbild der Prozessorperipheriegeräte.

In naher Zukunft wird die Schaltung der Prozessorperipheriegeräte also so aussehen. Auf der Speicherplatine verbleiben nur Speicherchips und Signalanpassungsschaltungen mit der Relaisschaltung.

Über den 36-poligen Programmieranschluss können Sie den Programmierer anschließen und die Firmware auf den Computer herunterladen. Zusätzlich zum Programmierer mit dem erforderlichen Schnittstellenkonverter können Sie jedes andere Gerät verwenden. Zumindest ein Locherleser (ich habe übrigens einen mit Locher und sogar einer Bandspule), sogar ein Bedienfeld mit Kippschaltern.

Infolgedessen stellt die Relaislogik eine bestimmte Schnittstelle bereit, und der Schnittstellenkonverter kann eine beliebige sein. Der Parallelschnittstellenstecker ist übrigens kompatibel mit LPT ...

Demonstration der Arbeit und des aktuellen Status


Zunächst wurde das Hello World-Programm aus dem Wikipedia-Artikel auf dem Computer ausgeführt.

Der Quellcode lautet wie folgt:

++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++
.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.
------.--------.>+.>.

Dank des LED-Panels können Sie deutlich sehen, wie sich die Daten ändern:


Obwohl es bei einer Frequenz von 25 Hz schwierig ist, den Überblick über die Vorgänge im RAM zu behalten.

Eine nützlichere und praktischere Aufgabe besteht darin, die Vorzeichen der Zahl Pi nach dem Dezimalpunkt zu berechnen. Es ist klar, dass moderne Computer dieses Problem mit bis zu 31,4 Billionen Zeichen gelöst haben. Die Tatsache, dass BrainfuckPC diesen Vorgang ausführen kann, legt nahe, dass der Relaiscomputer nicht zu 100% nutzlos ist, sondern nur zu 99,9.

Zunächst fand ich einen vorgefertigten Berechnungsalgorithmus, der in Brainfuck geschrieben wurde .

> ++++ (4 digits)
[<+>>>>>>>>++++++++++<<<<<<<-]>+++++[<+++++++++>-]+>>>>>>+[<<+++[>>[-<]<[>]<-]>>
[>+>]<[<]>]>[[->>>>+<<<<]>>>+++>-]<[<<<<]<<<<<<<<+[->>>>>>>>>>>>[<+[->>>>+<<<<]>
>>>>]<<<<[>>>>>[<<<<+>>>>-]<<<<<-[<<++++++++++>>-]>>>[<<[<+<<+>>>-]<[>+<-]<++<<+
>>>>>>-]<<[-]<<-<[->>+<-[>>>]>[[<+>-]>+>>]<<<<<]>[-]>+<<<-[>>+<<-]<]<<<<+>>>>>>>
>[-]>[<<<+>>>-]<<++++++++++<[->>+<-[>>>]>[[<+>-]>+>>]<<<<<]>[-]>+>[<<+<+>>>-]<<<
<+<+>>[-[-[-[-[-[-[-[-[-<->[-<+<->>]]]]]]]]]]<[+++++[<<<++++++++<++++++++>>>>-]<
<<<+<->>>>[>+<<<+++++++++<->>>-]<<<<<[>>+<<-]+<[->-<]>[>>.<<<<[+.[-]]>>-]>[>>.<<
-]>[-]>[-]>>>[>>[<<<<<<<<+>>>>>>>>-]<<-]]>>[-]<<<[-]<<<<<<<<]++++++++++.
Ein Problem - obwohl gesagt wird, dass dieses Programm viel schneller ist als irgendein anderes Programm, berechnet es immer noch das nächste Zeichen, es ist extrem langsam.


Abb. 13: Zeit, die benötigt wird, um N Stellen von Pi nach dem Dezimalpunkt auszugeben.

4 Dezimalstellen müssen fast anderthalb Stunden warten ...


Abb. 14: - Pi = 3! - Wie unhöflich!

Es konnten jedoch nicht einmal zwei Zeichen abgeleitet werden. Stattdessen gab der Computer an, dass Pi 4 war, und beendete den Auftrag.


Abb. 15: Er weiß genau, dass Pi nach dem Kriegsrecht bis zu vier sein kann.

Ich entschied mich für den anderen Weg und schrieb einen Bruchrechner
 frac355113=3.141592.... Genauigkeit - 6 Dezimalstellen! Dies ist das genaueste Ergebnis für Brüche mit einer angemessenen Größe.

Nach drei schlaflosen Nächten habe ich ein Programm über Brainfuck geschrieben, das zwei Zahlen ineinander teilen und das Ergebnis mit einem Gleitkomma an das Terminal ausgeben kann. Das Urteil des Emulators lautet wie folgt: 60.000 Anweisungen sind erforderlich. Im letzten 10 Tausend pro Zeichen:


Abb. 16: Die Zeit, die benötigt wird, um die nächste Dezimalstelle bei der Berechnung des Bruchs auszugeben.

Wie schnell werden die nächsten Werte angezeigt? Ich muss sehr schnell sagen im Vergleich zum vorherigen Programm!

Das Glück war jedoch nur von kurzer Dauer - der Computer begann im 16-Bit-Modus zu versagen. Die Diagnose ergab, dass die Speicherkarte täuscht - sie setzt ständig das 13. Bit. Ich werde eine neue Speicherkarte erstellen und alles wird vergehen, aber im Moment werde ich mich auf einen Bruchteil beschränken  frac227=3.14...zwei Dezimalstellen und 8-Bit-Betriebsart. Am wichtigsten ist, dass nur 1.600 Anweisungen befolgt werden müssen! Bei einer Frequenz von 25 Hz ist dies etwas mehr als eine Minute.


Wiederholt und pfeifend bewältigt der Computer die Aufgabe.

Fortsetzung folgt ...


Jetzt können Sie auf dem Computer Programme ausführen, für die keine Benutzereingaben erforderlich sind. Bisher habe ich die CTRLIO.CIN-Anweisung nicht trivial vermasselt :) Und ich werde dies in Kürze nicht mehr tun. Der Computer ist derzeit zu 98% fertig. Und nach zweijähriger Arbeit haben sich viele Projekte angesammelt, die auf den Moment warten, in dem ich mich mit ihnen befassen werde.

Deshalb wechsle ich zu anderen Projekten


Erstens ist dies ein Röhrencomputer, der auf Kommutatordekatrons basiert. Ich habe bereits sowohl einen Schlag als auch die Dekatronen selbst (obwohl meistens A101 - der Computer wird noch langsamer als das Relais auf ihnen herauskommen - wir brauchen A103). Sogar 700 Vakuumröhren sind bereits verfügbar und vieles mehr ...



Ich habe einen Speicher dafür vorbereitet - 16 Stück integrierte Speicherwürfel für jeweils 128 16-Bit-Wörter. Innen - Mehrlochferritplatten, eine Art Gedächtniszweig auf Ferritringen.

Ich vergesse auch nicht die Lungenentzündung - mein Freund Anton beschäftigt sich mit der Natur. Experimente, aber dazu beim nächsten Mal mehr.

... die folgenden Unvollkommenheiten hinterlassen. Ich werde einen Teil des Problems für das Festival Ende Mai lösen, Teil - nein:

  • Eine neue Speicherkarte, auf der nur RAM-Chips und deren Kabelbaum installiert sind. Es gibt eine Leiterplatte für die Speicherkarte, die Leiterplatte ist noch nicht geschieden. Zu Hause wird es zu faul sein, dies zu tun (eine ziemlich dichte Zwei-Wege-Karte), daher werde ich diese Karte in die Reihenfolge aufnehmen, wenn ich Karten für ein paar andere Projekte bestelle - eine mechanische Uhr an einem Relais und ein Pneumoskop.
  • Zusammen mit der neuen Speicherkarte werden Messuhren, normale Terminal-Anzeigehardware und unabhängige Logik zur Aktualisierung des LED-Panels geliefert.
  • Der Programmierer, oder besser gesagt, die Entwicklung der Firmware dafür. Wenn Sie eine alte Speicherkarte haben, ist diese im Allgemeinen redundant. Da jedoch der Programmieranschluss verfügbar ist, können Sie das Programm bereits damit laden.
  • Die Logik des Timings. Hier bin ich ganz faul, weil dort buchstäblich 3 logische Module gebunden sind. Ich werde es definitiv für das Festival Ende Mai tun.
  • Leseanweisung von der Konsole. Es ist an die Logik des Timings gebunden (im synchronen Betrieb muss der Computer den Betrieb stoppen und auf das Eintreffen der Daten warten).
  • Senden Sie eine Anfrage an das Guinness-Buch der Rekorde ... Als schnellster Relaisprozessor und gleichzeitig am langsamsten lesend. 16 milliFlops ist nichts für dich, um einen Pelzmantel in Unterhosen zu stecken (aus Kommentaren auf Youtube).

Bild

Die gesamte Dokumentation auf dem Relay-Computer befindet sich im Repository von GitHub . Sie können den Status in jedem sozialen Netzwerk über die Links in meinem Profil überwachen.

UPD: Ich habe mich geweigert, am Festival teilzunehmen.
Und doch - vom 25. bis 26. Mai findet in Moskau auf dem Territorium der Brotfabrik das erste Festival für handwerkliche Produktionen und DIY-Kultur Antifactory statt. Ich werde dort mit einem Relais-Computer anwesend sein und einen Relais-Controller für die automatische Bewässerung mitbringen . Der Eintritt zur Veranstaltung ist frei, Sie sind also in diesen Tagen in Moskau - verpassen Sie nicht die Chance, mein Staffelmonster live zu sehen. Wenn ich es sicher und gesund mitbringe, werde ich es auf jeden Fall in der Arbeit demonstrieren.

Source: https://habr.com/ru/post/de442732/

More articles:


All Articles