Forth-Diskussion und Infos

Einen Jupiter Ace hätte ich auch gerne ..... hab aber eine NC4000 CPU - die direkt FORTH verarbeitet

Zitat von nalkem

Einen Jupiter Ace hätte ich auch gerne

Ich hatte mal einen in der Sammlung, ist eine coole Maschine nur das Gehäuse-Plastik ist dünner als ein Joghurtbecher, dagegen sind sogar die tiefgezogenen ZX80 Gehäuse stabil :0) (Aber cool ist er doch ;0))

Forth gefällt mir, liegt wohl an der UPN, das oben verlinkte Buch ist großartig.

Wenn ich länger mit Forth arbeiten würde, dann hätte ich bald ein riesiges standard Dictionary.

Natürlich würde man dann bei jedem neuen Projekt das standard Dic immer mitnehmen.

Dadurch würde der "Rucksack" immer größer werden ...

Gibt es denn Tools, die automatisch nicht verwendete Wörter finden und löschen können?

Zitat von nalkem

Einen Jupiter Ace hätte ich auch gerne ..... hab aber eine NC4000 CPU - die direkt FORTH verarbeitet

Ich war heute auch mal auf der Suche wo man auf einem kleinen System FORTH laufen lassen kann.
Die Arduinos scheinen beim speichern etc etwas karg im Handling zu sein - ausserdem hab ich keine Ahnung welche FORTH-Version/Implementierung gut waere.

Optisch gefallen hat mir - mal wieder - eine ESP32-Version, aber hier eine die auch die FabGL wie bei RunCPM nutzt.

Sie nennt sich ESP32-Forth-Computer

Zitat

Computer made with ESP32 microcontroler

Use https://github.com/fdivitto/fabgl (with a modification)
Inspired by JupiterAce computer
Inspired by ColorForth language

Leider bekomme ich diesen nicht fertig compiliert, obwohl ich sogar bis zur FabGL v1.0.3 zurueck gegangen bin. Bei dieser sieht die vgabasecontroller.h noch so aus wie im Read.Me beschrieben.
Dort muss man

volatile uint8_t m_HVSync;

aus dem protected in den public Bereich verschieben.

[EDIT]

jetzt hat es doch geklappt Man muss nur die Fehlermeldung lesen
intr_handle_t m_isr_handle; war auch noch im protected Bereich und muss auch in public verschoben werden. (steht aber nicht auf der github-page)

D.h. es sieht so aus am Ende des public-Breiches fuer FabGL v1.0.4/v1.0.5
(bei der v1.0.3 bleibt das auskommentieren von setRawPixel aus):

  uint8_t createRawPixel(RGB222 rgb)             { return preparePixel(rgb); }
  uint8_t createBlankRawPixel()                  { return m_HVSync; }
  // void setRawPixel(int x, int y, uint8_t rgb)    { VGA_PIXEL(x, y) = rgb; }
  // contains H and V signals for visible line
  volatile uint8_t       m_HVSync;
  intr_handle_t          m_isr_handle;

protected:

Optisch was dazu zu sehen (meist leider nur in spanisch) gibt es in der ESP32-Forth-Computer Video-Reihe

Zitat von Toast_r

'Forth in klein' hatten wir auch hier schonmal: RE: Zusatzveranstaltungen zur CC2013

"Zugriff verweigert" ::

Zitat von guidol

[EDIT]

jetzt hat es doch geklappt Man muss nur die Fehlermeldung lesen
intr_handle_t m_isr_handle; war auch noch im protected Bereich und muss auch in public verschoben werden.

Mit dem Autor Pablo Hugo Reda (phreda4) aus Argentinien und ackerman (rpsubc8) von retrowiki aus Spanien haben wir das Problem hingebogen bekommen

Zitat von nalkem

hab aber eine NC4000 CPU - die direkt FORTH verarbeitet

Bin der Sache mal nachgegagen und mir scheint, daß die evtl dem hier gut entsprechen könnte

https://www.computerwoche.de/a…ysteme-im-aufwind,1161785

außerdem hat das schicke Wiki von oben auch was dazu

https://wiki.forth-ev.de/doku.php/mcv:forthcpu (das oberste)

Der Chip ist wirklich witzig. Und in Form der Nachfolger, dann auch noch interessanter, da dann der Stack mit auf dem Prozessor sitzt.

Info's zum NC4000 - der aber schnell auf NC4016 umbenannt wurde - gibt es da

datasheet (1) https://en.wikichip.org/wiki/novix/nc4016 , https://en.wikichip.org/w/inde…=File%3Anc4016.pdf&page=1

datasheet (2) https://datasheet4u.com/datash…/NC4016/pdf.php?id=558746

Buch und Beschreibung von Herrn Koopman

https://users.ece.cmu.edu/~koo…tack_computers/index.html

https://users.ece.cmu.edu/~koo…ack_computers/sec4_4.html (!) und die anderen Abschnitte von Kapitel 4 und 5 ansehen

https://www.amazon.com/Stack-C…pplications/dp/0745804187

versteckt im Wust der Netzdaten gibt es auch PreliminaryReportOnTheNOVIX4000,CLStephens,WPWatson.pdf

und bei diesen Seiten hier gab es einen SEHR schönen Artikel über Forth und Forth Chips allgemein

https://www.cpushack.com/2013/…e-forth-stack-processors/

https://www.cpushack.com/2013/…rom-space-to-greenarrays/

dort gibt es die Forth Variante für das System mit NC4000 / NC4016

https://github.com/ForthHub/cmFORTH

und in UK den Vorgänger auf großem Board (Bild und interessanter Text)

http://www.computinghistory.or…/Novix-NC4000-Beta-Board/

eine vermutlich ziemlich komplette Übersicht über die verfügbaren Forth Chips findet sich bei

http://www.ultratechnology.com/chips.htm

und einen davon (für den ich oben den Katalog verlinkt hatte, Rockwell) gibt es bei reddit zu sehen

https://www.reddit.com/r/Forth…uilt_in_the_80s_based_on/

die auch eine eigene Forth Abteilung haben

https://www.reddit.com/r/Forth/

Noch ganz generell gut gefunden, wenn auch nicht komplett angesehen, war diese kurze deutsche Einführung

http://www.andreadrian.de/8_Bi…index.html#mozTocId156701

und bei der BYTE gab es mal ein ganzes Heft zum Thema

https://archive.org/details/by…980-08/page/n101/mode/2up , auch Seiten p76 (C.Moore) und p150

_{(nebenbei gibts da auch eine Bauanleitung für ein FOURTH Generation Bildschirmterminal, p210 ; und jede Menge Forth Werbungen)}

ForthFAQ gibts bei

http://www.faqs.org/faqs/computer-lang/forth-faq/part1/ oder

http://forth.org/faq/ (Textversion)

Leider fand sich der Artikel "Larkin : Forth Implementation on the Acorn RISC" nicht als PDF o.ä.; hätte ich gern aml reingeschaut. Wäre evtl. interessant, da das wohl die Beschreibung für das spätere Produkt RiscFORTH auf dem ARM ist. Siehe Bild unten rechts. Wenn den jemand hat ... bitte mal Bescheid geben.

dafür gibt es einen ersten "(Vor)Bericht" über den NC4000 - in den Forth Dimensions Vol 7 No 2 , Seite 12

http://forth.org/fd/FD-V07N2.pdf

war nicht direkt "günstig" aber "krass" schnell ; 7.5 MHz und 10 MIPS stand irgendwo.

Der ARM hatte da ungefähr 4 MIPS (und 12 bei 25MHz) und war nun nicht direkt langsam.

Ein Kollege arbeitet an einer eigenen 32 Bit Risc cpu. Da könnte Forth eine gute erste Programmiersprache sein, falls jemand mal was eigenes implementieren möchte.

Die Leute/User vom ESP32fort (nicht zu verwechseln mit dem ESP32 Forth Computer)

nennen ihr ESP32forth eine Bare-Metal version.

Also keine "echte" Forth-CPU, aber doch mit einem Forth-Kernel und kein anderes OS drunter.

ESP32forth kann per USB-seriell oder ueber WebUi (ueber die ESP32 WLAN-Verbindung) angesprochen werden.

Zitat von guidol

ESP32forth kann per USB-seriell oder ueber WebUi (ueber die ESP32 WLAN-Verbindung) angesprochen werden.

Die BETA v7.0.6.5 von hier kann nun auch telnet als Verbindung

auf dem COM-Port:
z" MyWifi_SSID" z" MyWiFiPassword" webui

in der webui:
telnetd 23 server

dann verbinden per puTTY auf Telnet

Obs noch besser/direkt geht?

[EDIT] scheinbar schon:

auf dem COM-Port:
z" MyWifi_SSID" z" MyWiFiPassword" login
telnetd 23 server

Zitat von daybyter

Ein Kollege arbeitet an einer eigenen 32 Bit Risc cpu. Da könnte Forth eine gute erste Programmiersprache sein, falls jemand mal was eigenes implementieren möchte.

Das scheint gar nicht so wirklich ganz schwierig zu sein, da nur die allerbasalsten Kommandos da sein müssen (so Kommandos wie "!" und "@" und DROP und SWAP). Für alles obendrüber gibt es in dem schönen Buch Footsteps in an Empty Valley - NC4000 Single Chip Forth Engine - Fourth Edition - 2017 zum NC4000 ForthProzessor eine schöne Anleitung wie sowas gehen kann (ab Seite 61). Nicht daß ich das könnte ... aber es sieht verständlich aus.

Das komische an der Struktur mit Forth vs. "normaler Prozessor" ist aber eben genau, daß es eben dann ein Registerprozessor ist und kein Stackteil. Und insbesondere wenn das dann noch ein RISC ist mit einer LOAD-STORE Strukur killt das eigentlich von vorneherein die Performance - by design.

Keine Ahnung was und in welchem Zusammenhang der "Kollege" da was baut (real oder virtuell, aus Spaß an der Freude oder als Profibastler), aber je nachdem, wie weit das gediehen ist, könnte das ja evtl. eine extrem spannende Erweiterung sein. Es müßte halt entweder viele Register geben, die man zusammen als einen Stack ansprechen kann und R0 ist halt das Toplevel für die drei nötigen Forthworte in Hardware und DUP z.B. shiftet dann alle Register eines nach unten und macht ein Kopie von R1 nach R0, bzw. besser behält gleich den Wert von R0 bei. Mit 16 Registern macht das wahrscheinlich noch nicht viel Sinn - vermutlich 32 könnte schon gut passen.

Andere Variante, die auch schön klingt (theoretisch) wäre, daß jedes Register quasi untergeordnet einen eigenen on-chip RAM Bereich als Stack hat. So in der Art eines zusätzlichen Level 1 Caches und im Forth Mode wird halt nicht klassisch gecached, sondern die Register bekommen ihren je fix zugeordneten Stackbereich. Der Witz an sowas wäre, daß man quasi Kontextswitch machen könnte, ohne Daten zu verlieren, etwa indem man eine solche Stackreihe eines Registers (eine Line) etwa für Interrupts freihält und z.B. Register R15 inkl. seiner Line nur im Interrupt benutzt wird und man dann für alle anderen Dinge noch R0 bis R14 hat, die man quasi durchwechseln kann. Und man könnte auch - nachdem man den Cache komplett gespeichert hat - auf Normalmode schalten und dann sind es wieder normale 16 Register (oder 32 oder 128 oder ... mehr).

Das !ARMForth32 ist wohl primär ein BASIC Programm, was dann die Forthmaschine erzeugt, und die benutzt man dann. Vielleicht ist das ja schon gut verständlich, um zu schauen, wie man sowas (ohne die RegisterLine Geschichte) macht. Läuft wohl auch auf aktuellen ARMs unter RISCOS, also Raspberry, ARMini und Co

http://www.rforth.uk/index.html

Habe es aber noch nicht auf echter Hardware angeschaut. Klang aber gut. Es gibt - für Leute, die FORTH nur mal so anschauen wollen, da auch ein paar hübsche Beispielprogramme drinnen, die z.B. GPIO Ports ansteuern und Graphicausgabe bereitstellen (über den OS SWI). Das sieht man auch schön, wie künstlich so ein Forth auf eine Registermaschine aufgesetzt ist.

Der Kollege ist M. J. aus dem forum64. Es geht um eine eigene CPU die in Verilog geschrieben ist und auf dem mini dev fpga Board mit Maiks Shield läuft. Kann Dir einen Kontakt machen, wenn Dich das interessiert.

Das kann ich immer nur bewundern.

Beim Verständnis hapert es dann aber ziemlich sicher. Ist irgendwie eine Ebene zu tief - quasi die Kelleräume oder das Fundament der ganzen Geschichte - und man kann nun auch nicht alles querlesen. Ich weiß schon nicht, was das(!/?) "mini dev fpga Board" sein soll.

Aber wenns mal irgendwo in für Uneingeweihte verständlicher Form dargestellt aufgeschrieben ist oder vorgestellt wird, schau ich mir auch das gern mal an.

Oh, entschuldige. Da hab ich wohl einfach zuviel vorrausgesetzt, weil ich schon so lange damit rummache.

Das mini dev Board ist ein älteres Cyclone 2 Board, welches lange Zeit wohl eines der billigsten Einsteigerboards in die FPGA Materie war. Hat die ganze Zeit so 15,- mit USB Programmieradapter gekostet. Jetzt ist es etwas teurer geworden.

Dieses Board mein ich:

https://de.aliexpress.com/item/4001251601848.html

Das Board hat viele Pins, aber ihm fehlen halt so Standardanschlüsse wie VGA, Tastatur usw. Im Sinne eines Arduino Shields rüstet die eine Aufsetzplatine nach:

https://oe7twj.at/index.php?ti…44-Mini#Maik_Shield_-_MK1

Das Board hat über 4000 Logikzellen, was mit ein paar Kniffen auch für eine 32 Bit RiscV CPU z.B. reicht:

https://github.com/maikmerten/spu32

https://www.youtube.com/watch?v=TEiRZs2AKJg

Ich hab tatsächlich mal eine Einführung in das Thema versucht, aber das Interesse ist wohl recht gering:

https://www.forum64.de/index.php?thread/83766-fpgas/

Bei Fragen kannst Du mich gerne anschreiben.

Ciao,

Andreas

daybyter Sehr interessant. Gibt es die Anleitung inklusive Abbildungen ggf nochmal komplett, ohne sich dafür im Forum64 registrieren zu müssen?

Gruß

Hier gibt es ein C64 Handic Forth (EPROM und *.crt File) als auch das Handbuch dazu:

https://archive.org/details/handic-forth-64

Zitat von Bodhi1969

Dann ist eingefallen, dass es ausserdem mit dem Canon Cat einen weitereren "Rechner" auf FORTH-Basis gibt.

Dieser Wikipedia Eintrag verweist auch auf einen Canon Cat Emulator

Da im ZIP sind die ROM files um die Canon Cat auf MAME zu starten.

Klappt auch mit dem neuesten MAME

Allerdings steht im Internet auch was von einer JavaScript-Emulation, die habe ich aber nicht gefunden.

Zitat von escimo

daybyter Sehr interessant. Gibt es die Anleitung inklusive Abbildungen ggf nochmal komplett, ohne sich dafür im Forum64 registrieren zu müssen?

Gruß

Glaub nicht. Das Allermeiste ist ohnehin in einer nicht-öffentlichen Konversation diskutiert und erarbeitet worden. Was schade ist, weil da ne Menge Wissen drinsteckt. Aber wenigstens kann man neue Leute hinzufügen, wenn jemand Interesse bekundet.

Für Maiks RiscV cpu haben wir übrigens mal ein in C geschriebenes Forth compiliert. Aber da hat niemand genug Ahnung, um weiter was damit zu machen.

Danke für die Info.

Heute war das 17te Online-Meeting von Forth2020.org (ca. 5 Stunden) auf Zoom.

War eine nette Runde und kurz danach gab es eine neue BETA von ESP32forth:

die v7.0.6.6 die 2 "Vorteile" hat:

- laesst sich mit ESP32 Core v2.0.1 kompilieren

- hat Anpassungen (Deaktivierung nicht vorhandener Funktionen
fuer ESP32-C3 und ESP32-S2 - so dass es auch fuer diese CPUs laeuft
(keine Unterstuetung fuer SD_MMC-lib (S2&C3) und DACs (nur C3))

D.h. aber nicht, dass der S2 in RunCPM nicht die SDFat-Lib unterstuetzen wuerde

Der Commit dazu ist hier.

Da es jetzt auf dem ESP32-S2 laeuft, klappt dies auch auf meinem tuerkischen Deneyap mini

Morgen bekommt deshalb meine 2ter seine Pin-Beine angelotet (noch ist er eingepackt).

Eben habe ich mit einem USBtiny ISCP-Programmer FlashForth 5.0 auf meinen Arduino MEGA 2560 Clone gebracht (fand nichts fuer den staerkeren Arduino Due).

Per USBtiny war notwendig, da das FlashForth einen anderen Bootloader nutzt als normal bei Arduinos.

Der USBtiny wurde laut Windows 10 zwar erkannt und sei einsatzbereit, war er dann aber laut Systemsteuerung doch nicht.

Also das ganze auf einem armbian-Linux System mit avrdude gemacht

sudo avrdude -c usbtiny -p atmega2560 -e -u -U flash:w:2560-16MHz-38400.hex:i -U efuse:w:0x07:m -U hfuse:w:0xda:m -U lfuse:w:0xff:m

Also 8 Buzzwords in 3 Sätzen - das ist bißchen happig, um da direkt die Informaion rauszulesen.

Mein Verständnis bisher ist, daß der USBTiny ISP, mit dem man wohl Chips programmieren kann ( https://learn.adafruit.com/usbtinyisp ), nicht funktioniert hat.

Und daß auch USBTiny wohl nur mittelbar was damit zu tun hat. https://dicks.home.xs4all.nl/avr/usbtiny/

avrdude - https://www.mikrocontroller.net/articles/AVRDUDE - dagegen ist eine Software, die solche Sachen wie das Forth in solche Sachen wie einen Atmel Chip einspielen kann. Und das über verschiedene Varianten (parallel, seriell ...).

Die große Frage ist ja nun aber: was machst Du mit dem Forth nun. Eigentlich nett wäre ja so ein Benchmark, der exakt das gleiche Apfelmännchen zeichnet wie das, was hier immer mal für BASIC auftaucht. Da könnte man schön vergleichen.

Wo Forth genrell auch bißchen schwach zu sein scheint ist echte Pixel-Grafik, da gibt es zwar anscheinend immer mal solche Upgrade Wörterbücher, aber es scheint insgesamt relativ selten benutzt worden zu sein dafür.

Zitat von ThoralfAsmussen

Also 8 Buzzwords in 3 Sätzen - das ist bißchen happig, um da direkt die Informaion rauszulesen.

Sorry kommt mir garnicht so vor...

Doch der USBtiny selber ist OK, nur unter Windows 10 wollte der Treiber nicht (Fragezeichen in der Systemsteuerung)

Bevor ich nun mir da gross Arbeit mache (weil ich ja nur meinen Chip flashen wollte) habe ich es unter armbian/Linux gemacht, da war die Unterstuetzung fuer den USBtiny kein Problem.

Der avrdude wird auch von der Arduino-IDE zum flashen genutzt (aufgerufen) wenn das .ino fertig kompiliert wurde.

Das ist dann im Fenster zu sehen, wenn die Arduino-IDE den Arduino connected und flasht.

Da die meisten Forth-Systeme textbasiert sind, koennte man schauen wie man solch ein Apfelmaennchen umsetzt.

Dazu wuerde ich aber im Netz mal "wuehlen", weil Forth kann ich noch nicht.

Forth will ich mir mal ansehen, weil ich Kontakt zu Leuten gefunden habe die es nutzen und ich es interessant finde, weil es auf vielen kleinen Systemen laeuft - fast mehr als BASIC auf Arduinos.

Pixel-Grafik wird es kaum geben, da sind die Systeme zu unterschiedlich.

Es gibt zwar einige Forth-Standard-Versionen (Befehlsumfang) aber trotzdem schwankt die Vrefuegbarkeit der Befehle (in Forth werden die Words genannt)

Für die riscv cpu von Maik wurde ein ascii Ampfelmännchen und ein Pixelmännchen in C geschrieben. Könnte man ggf umsetzen...

https://youtu.be/LjN_SxblH2U