Um den PicoCalc ausreichend würdigen zu können ist ein Ausflug in die Vergangenheit von Vorteil. Es gab mal eine Zeit in der Computer im normalen Alltag eines Menschen keine Rolle spielten, das Wort Computer sogar für viele unbekannt war. Erst Anfang der 70iger Jahre, als es mit den programmierbaren Taschenrechnern die ersten – sehr kostspieligen – programmierbaren Geräte für Endverbraucher zu kaufen gab, hielt ‚Computer‘ allmählich Einzug in die normale Alltagswelt.

Kurz danach gab es Microcomputer, oft ohne Display und Tastatur und dann die ersten Homecomputer, die an einem Fernseher angeschlossen und meist mit der Programmiersprache BASIC ausgestattet, ein deutlich komfortableres Programmieren ermöglichten.

Zu dieser Zeit war ich auch oft in der örtlichen Discothek unterwegs. Dort hatten sie in einer langen Reihe viele der damals aktuellen Spielautomaten aufgestellt. Zu meinen Lieblingsspielen gehörte Missile Command und später Xevious. Im Missile Command Automaten war eine riesige Metallkugel verbaut – ein erster Trackball!

Xevious wurde auf einem vertikal eingebauten Monitor mit 224 × 288 Pixel und Missile Command mit 256 × 231 Pixel dargestellt. Beides deutlich mehr als die 160 x 200 Pixel des Commodore 64, den ich damals besaß. Ich stand vor den Automaten und überlegte wie man das auf dem C64 realisieren könnte. Es schien mir anfangs unmöglich diese Spiele mit ihrer Farbenpracht auf meinem C64 in BASIC nach zu programmieren. Doch mit Assembler und Sprites war es möglich.

Mit meinem ersten Taschenrechner (Privileg PR-56 D-NC, 72 Schritte) habe ich unendlich viel Zeit damit verbracht den GGT und das Streichholzspiel zu programmieren und auf dem C64 habe ich mit einem Assembler mit ‚Conways Game of Life‘ mein erstes Programm in einem Magazin (CHIP) veröffentlicht und mit einem universellen Datenbank Programm ‚MiniDat‘ ein erstes Programm verkaufen können.

Einer der Gründe warum ich programmierbaren Taschenrechner mag, ist ihre Vollständigkeit trotz geringer Größe und der dadurch gegebenen Mobilität. Mit Vollständigkeit meine ich, das sie alles besitzen um autark verwendet werden zu können: Einen Mikroprozessor und eine Ausgabe- und eine Eingabemöglichkeit. Dadurch war es möglich sich an nahezu jedem Ort in der Unendlichkeit des Programmierens zu verlieren. Zum Beispiel in der Schule, wenn man den Taschenrechner knapp unter das Pult hielt.

Im Verlauf meines Lebens bin ich den programmierbaren Taschenrechnern treu geblieben. Von Zeit zu Zeit sehe ich nach was es Aktuelles gibt und wenn etwas Interessantes dabei ist so kaufe ich es mir. Viel zu spät habe ich den fantastischen TI-89 entdeckt, der mit dem eingebauten CAS Derive eine neue mathematische Dimension für Schüler frei schaltete. Und mit dem HP Prime besitze ich einen sehr modernen Taschenrechner.

Was hat das jetzt alles mit dem PicoCalc zu tun?

Der PicoCalc hat die vertikale Bauform der damaligen programmierbaren Taschenrechner übernommen. Er besitzt ein eingebautes Keyboard und ein wundervolles Display, welches beim ersten Einschalten einem mit grünen Pixelzeichen entgegen leuchtet, grad so wie auf den ersten Monitoren, die man an damalige Computer angeschlossen hatte. Schaltet man den PicoCalc ein, so booten weder Linux noch Windows, sondern es blinkt einen freundlich ein Basic Cursor mit der Aufforderung an, doch gleich einmal ein paar BASIC Zeilen einzutippen. Denn das BASIC ist gleichzeitig die Schnittstelle zu allen Funktionen des PicoCalc. Aber er heißt PicoCalc und das ‚Calc‘ suggeriert dass er ein Taschenrechner sei und analysiert man unter diesem Gedanken das Keyboard, so scheint einiges zu fehlen, was so ein typischer Taschenrechner an Tasten besitzt. Da ist kein Zehnertastenblock mit direkt daneben liegenden ‚+‘, ‚-‘, ‚*‘, ‚/‘ und ‚=‘ Taste. Auch die transzendenten Funktionen scheinen zu fehlen und man könnte darob enttäuscht sein. Aber weit gefehlt, alles ist da und wird nur etwas anders eingetippt:

?sin(4*5)+cos(3+2*7) [Enter]

und der PicoCalc präsentiert:

0.6377819127

Es ist also ohne weiteres möglich ihn für Rechnungen in der Schule oder dem Studium zu verwenden. Noch dazu kann man schon eingegebene Rechnungen und ihre Ergebnisse sehen und wieder verwenden! Allerdings besitzt er standardmäßig weder die speziellen Funktionen eines Grafikrechners noch kann er Computer Algebra (CAS). Theoretisch ist es aber möglich ihm mit einer anderen Firmware die fehlenden Dinge beizubringen oder man programmiert sich die Grafikfunktionen einfach selbst in BASIC.

Der PicoCalc ist ein wahr gewordener Traum von mir. Mein ganzes Leben träumte ich von einem immer noch besseren programmierbaren Taschenrechner. Wie ich schon in Artikeln von mir schrieb, faszinierten mich damals die Programmierfähigkeiten eines programmierbaren Taschenrechners bei weitem mehr als seine mathematischen Fähigkeiten. Denn es gab trotz aller Faszination einfach sehr viele programmiertechnische Einschränkungen und ich habe mir immer einen noch besseren Taschenrechner gewünscht. Der PicoCalc ist genau das was ich damals gerne gehabt hätte: Eine kleine Programmiermaschine, die ich überall hin mit nehmen kann. Dazu ein im Vergleich zu den Anzeigen damaliger Taschenrechner wie dem HP-25 mit 10 7-Segment LED Stellen oder dem HP-41C mit 12 14-Segment Stellen, ein fantastisches Farbdisplay mit 320 x 320 Pixeln. Auf dem man sogar einzelne Farbpixel setzen kann. Also ideal um selbst kleine Spiele zu entwickeln. Und sogar die Möglichkeit vernünftig Sound auszugeben. Sein grüner Bildschirm mit den 8 x 13 Punkt Zeichen erinnert sehr an die auf dem C64 gebräuchlichen 8 x 8 Zeichen.

Es geht noch viel mehr mit ihm, aber dazu komme ich später noch. In seiner puren Form kann man ihn einfach einschalten, mit ‚EDIT‘ [Enter] den Editor aufrufen und ist mitten im Programmcode. Kein Computer den man erst hoch fahren, keine Entwicklungsumgebung die man erst installieren muss! Einfach einschalten und loslegen. Ob in der Küche, im Schlafzimmer, im Garten oder gar auf der Toilette, immer kann man sofort weiter programmieren. Diese Mobilität macht besonders Sinn, wenn man an den heraus geführten Pins irgendwelche Sensoren angeschlossen hat und so vielleicht im Garten unterwegs ist, um die Temperaturen an unterschiedlichen Orten festzustellen.

Mit BASIC kann ich jetzt auf einfache und logische Art zusammengesetzte Bedingungen angeben, wie zum Beispiel:

IF A < 4 OR B > 5 AND (C = 4 AND D = 5) THEN PRINT "Bedingung erfüllt!"

Nach jahrelangem Kodieren auf programmierbaren Taschenrechnern war das eine wahre Wohltat! In diesem Ausdruck kann man eine oder mehrere Variable direkt gegen einen Wert prüfen, kann mehrere Bedingungen mit AND und OR verknüpfen und sogar Prioritäten durch Klammern bestimmen! Schon allein die Darstellung macht es viel einfacher die Bedingung zu verstehen und nachzuprüfen. Mit den Bedingungsfunktionen alter programmierbarer Taschenrechner war das viel schwieriger zu kodieren.

Hardware

Der PicoCalc ist eigentlich nur ein Gehäuse mit einer Tastatur, einem Lautsprecher, einem Display und einem Akkuhalter. Da man den PicoCalc selbst zusammenbauen muss, was in 10 – 15 Minuten erledigt ist, kann das jeder Käufer selbst sehen. Der für einen Computer von entscheidender Bedeutung notwendige Mikroprozessor kommt von einem Raspberry Pico Mikrocontroller und wird einfach in den PicoCalc eingesteckt. Auf diesem ist standardmäßig die Programmiersprache MMBasic installiert, das nach dem Einschalten direkt zur Verfügung steht. Aber das Konzept mit dem Slot für Pico Boards ermöglicht es auch andere Picos einzusetzen:

• Pico 1 H

• Pico 1 WH

• Pico 2

• Pico 2 W

Damit kann man schon einiges machen, sogar den PicoCalc ins Internet bringen. Man kann aber noch deutlich mehr aus dem PicoCalc heraus holen, aber auch dazu komme ich gleich.

Da der Raspberry Pico ja ursprünglich als Bastel Mikrocontroller entwickelt wurde, besitzt er viele Ein- und Ausgabeleitungen, die beim PicoCalc zu einer am Gehäuserand sitzenden Steckleiste geführt wurden! Das macht es möglich, ohne das Gehäuse zu öffnen und ohne Löten, kleine elektronische Experimentierschaltungen direkt mit dem PicoCalc zu verbinden. Eines der einfachsten Beispiele ist es eine ganz normale handelsübliche 5mm LED direkt in GND und GP28 zu stecken und diese mit Hilfe des eingebauten MMBasic blinken zu lassen:

SETPIN GP28, DOUT
Do
  PIN(GP28) = 1
  PAUSE 500
  PIN(GP28) = 0
  PAUSE 500
LOOP

Für derlei Experimente ist es sehr sinnvoll den mitgelieferten Aufkleber, der die einzelnen Steckkontakte beschreibt, sorgfältig am PicoCalc anzubringen.

Das Keyboard enthält im Vergleich zu einem alten programmierbaren Taschenrechner keine Funktionstasten, dafür aber ein komplettes alphanumerisches Board im QWERTY Layout. Umlaute gibt es keine. Funktionen wie ‚SIN‘, ‚COS‘, TAN’ usw. müssen über ihre Einzelbuchstaben eingegeben werden. Die wichtigsten Tasten um mit dem MMBasic zu arbeiten sind aber alle da und so angeordnet, das ich recht flott damit arbeiten kann (Zum Beispiel um das Laufwerk umzuschalten: drive“b:“). Die Gummitasten funktionieren recht gut, benötigen aber einen definierten Druck. Sonst passiert es manchmal dass man drückt und auch eine taktile Rückkopplung (Tastenklick) bekommt, die Taste aber trotzdem nicht erkannt worden ist.

Das Display hat mit 320 x 320 Farbpixeln eine für Retrozwecke sehr gut passende Auflösung. Damit sind Programme aus der Vergangenheit ohne Bildschirmkompromisse nachprogrammierbar und durch die quadratische Auflösung kann man sich daran versuchen sowohl für vertikale als horizontale Spielautomaten erstellte Spiele darauf zu implementieren. Die Helligkeit ist im Haus ausreichend, draußen in der hellen Sonne wird es schwierig.

Das Design ist gut gelungen. Von oben sieht der PicoCalc aufgeräumt bis elegant aus. Von der Seite aus betrachtet ist er ein wenig dick, was aber wohl den 18650er Akkus geschuldet ist. Dafür ist aber im Inneren des Gehäuses viel Platz, was es ermöglicht dort zusätzliche Schaltungen unterzubringen. Hier hat zum Beispiel jemand ein Heltec WiFi LoRa 32 V3 in das Gehäuse des PicoCalc integriert und kann mit einer in MMBasic selbst programmierten Anwendung Nachrichten senden und empfangen.

MMBasic

Mit MMBasic hat sich ClockWork beim PicoCalc für eine interpretierende Programmiersprache entschieden und damit auf maximale Geschwindigkeit beim Ausführen eines Programms verzichtet. Das macht im Fall des PicoCalc aber mehr als Sinn, da es schwierig ist, eine auch nur halbwegs komfortable Entwicklungsumgebung auf das kleine Gerät zu bringen. Obwohl das vielleicht doch mit einem Nachbau von Turbo-Pascal 3.0 möglich gewesen wäre. Aber so spart man sich beim Entwickeln das Kompilieren und kann jede kleine Programmänderung mit einem Druck auf die [F2]-Taste sofort ausprobieren.

Davon abgesehen ist MMbasic schon allein aufgrund des deutlich höheren Takts des PicoCalc im Vergleich zu alten Homecomputern um ein Mehrfaches schneller.

Obwohl mit Python auch eine andere Interpreter Sprache für den PicoCalc zur Verfügung steht, ist MMBasic vorinstalliert, was unter dem Retro Gedanken, der hinter dem PicoCalc steckt, auch verständlich ist.

BASIC war ursprünglich bekannt dafür sogenannten Spaghetti Code zu fördern, da es, zum Beispiel auf dem Commodore 64, nur mit Zeilennummern als Sprungadressen arbeitet. Verzweigungen im Code mussten darum mit GOTO Zeilennummer erfolgen. Auch Unterprogramme konnten mit GOSUB nur über eine Zeilennummer erreicht werden. Selbst einfache Schleifen funktionierten nur mit Zeilennummern.

Aber als ob damit das Programmieren nicht schon schwierig genug war, verursachten die Zeilennummern noch ein anderes schwerwiegendes Problem. Wenn es bei der Fehlersuche oder der Weiterentwicklung eines Programms notwendig war neuen Code zwischen 2 Zeilennummern einzufügen, so funktionierte das nur wenn der Programmierer genügend Abstand vorgesehen hatte. Darum zeigen alte Listings von BASIC Programmen die Merkwürdigkeit, dass die Zeilennummern sich nicht kontinuierlich um 1 sondern stattdessen um 10 erhöhen. Das ermöglichte es zwischen zwei Zeilen 9 weitere einzufügen! Natürlich reichte das trotzdem oft nicht und dann hatte man ein echtes Problem und musste das ganze Programm oder zumindest Teile des Programms komplett neu organisieren. Dabei mussten auch oft die Zeilennummern bei den GOTO’s oder GOSUB’s angepasst werden. Eine Heidenarbeit! Jahre später gab es ROM Erweiterungen die eine ‚Renumber‘ Funktion enthielten, mit denen dieser zeitaufwendige Prozess automatisiert werden konnte.

Das ist zum Glück bei MMBasic nicht mehr der Fall. Hier kann mit modernen Methoden strukturiert programmiert werden und obwohl es noch Zeilennummern und auch das verachtete GOTO gibt, kann ein versierter Programmierer auf Beides verzichten. Übrigens gab es schon 1987 mit Borland Turbo Basic ein BASIC welches strukturiertes Programmieren ermöglichte und noch dazu ein Compiler war!

Ich bin über die modernen Anpassungen von MMBasic sehr froh. Im alten C64-Style hätte ich keine Lust mehr gehabt auf dem PicoCalc zu programmieren, aber so wie es jetzt ist, macht es Laune damit zu arbeiten und ich bin sicher dass damit auch grundlegendes Programmieren lernen möglich ist.

Wer schon existierende BASIC Programme für den PicoCalc anpassen möchte, oder für ein Projekt einen ersten Rumpf mit Hilfe einer KI entwickeln möchte, sei auf die einfache Entwicklungsumgebung MM Edit hingewiesen. Die läuft auf Notebook oder Desktop und ermöglicht so ein komfortables Editieren mit der gewohnten Tastatur, erlaubt Copy-and-Paste mit anderen Editoren und mit [F2] den schnellen Upload des Codes auf den PicoCalc.

Userport

Wie schon erwähnt, sind beim PicoCalc einige der beim Raspberry Pico vorhandenen Ein- und Ausgabepins seitlich an das Gehäuse zu einer Buchsenleiste verbunden. Das erlaubt es den PicoCalc als mobilen Steuerrechner für eine dort angeschlossene Schaltung oder Sensoren zu verwenden. Gerade für Entwicklungen die der Mobilität bedürfen – ich habe einmal an einem von einem Beschleunigungssensor getriggerten Bremslicht gearbeitet – kann so etwas Welten bedeuten. Denn so kann ich unterwegs direkt Parameter fein tunen oder notfalls auch einen Fehler debuggen. Und fällt einem der Computer herunter so wird das nicht gleich zum finanziellen Desaster. Das ist übrigens etwas, was mir an den Oxocards nicht so gut gefällt, die benötigen immer einen Computer mit einem komfortablen Browser, damit man damit arbeiten kann.

Im Zusammenhang mit dem Userport gibt es für mich als langjährigen RGB LED Fan noch ein weiteres Leckerli. Denn das spezielle Protokoll und der genau einzuhaltende Takt von ca. 800 KHz bei der Ansteuerung von WS2812 LEDs kann mit dem puren BASIC nicht so einfach erzeugt werden. Aber kein Problem, denn MMBasic hat einen speziellen Befehl eingebaut, mit dem es möglich ist die Farbwerte der LEDs zu setzen:

DIM b%(2)=(RGB(20, 0, 0), RGB(0, 20, 0), RGB(0, 0, 20)))
SETPIN GP28, DOUT
DEVICE WS2812 W, GP28, 3, b%()

Im Anhang finden alle ‚Knight Rider‘ Fans einen von mir programmierten Larson Scanner in MMBasic! Hier seht ihr ihn in Action:

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

Luckfox Lyra

Durch die Möglichkeit den gesamten Mikrocontroller auszutauschen ist es auch möglich das Pico Board durch ein pinkompatibles Luckfox Lyra Board zu ersetzen. Damit es ist möglich auf dem PicoCalc Linux (Buildroot OS) und damit wiederum Pico-8 laufen zu lassen. Damit hat man mit dem PicoCalc, seiner eingebauten Tastatur und dem quadratischen Display eine sehr gute Grundlage für den Pico-8. Allerdings ist die Konfiguration technisch anspruchsvoll:

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

https://www.heise.de/news/Luckfox-Lyra-Linux-im-Pico-Format-10366884.html

Was kann man noch mit dem PicoCalc machen?

Fuzix ist ein kleines UNIX-Betriebssystem.

Das habe ich nicht ausprobiert, da ich denke dass ich so etwas schon mit der uConsole habe und ich den PicoCalc nicht als weiteres Mini Linuxsystem sehe.

MP3Player ermöglicht das Abspielen von MP3-Dateien.

Ok, das ist nett um es einmal kurz auszuprobieren, aber für MP3s habe ich mein Smartphone.

NES ist ein NES-Emulator.

Den habe ich einmal kurz ausprobiert und ein Spiel, ich denke es war ‚Super Mario Bros. (World)‘ darauf zum Laufen gebracht. Es ist schön zu wissen dass das auch geht, aber ich denke da gibt es mittlerweile bei weitem besser geeignetere Retro Konsolen auf dem Markt. Zum Beispiel die Analogue Pocket.

uLisp ist ein Lisp-Interpreter. Den finde ich wiederum sehr interessant. Denn er ermöglicht die Erforschung einer nicht so üblichen und grundsätzlich anderen Programmiersprache. Ich habe ihn auf den PicoCalc geflasht und er scheint zu funktionieren.

Zusammenfassung

Mir gefällt der PicoCalc sehr gut. Hier gibt es für relativ wenig Geld ein sehr solides kleines Gerät mit dem man richtig gut überall Programmieren kann. Im Gegensatz zu bisherigen Lösungen wie der Clockwork uConsole oder dem schon recht alten 9-Dollar-Rechner C.H.I.P. geht es hier nicht den Weg über ein Linux System, auf dem dann alles andere basiert. Stattdessen geht es hier direkt nach dem Einschalten ins BASIC. Das ist sowohl retro als auch ein heutzutage extrem direkter Weg zum Programmieren! Das mit den heraus geführten Datenleitungen auch gleich noch die elektronische Welt erschlossen werden kann, setzt dem Ganzen die Krone auf.

Damit könnte man es mehr als gut sein lassen, aber das Konzept des PicoCalc bietet dem Bastler durch den austauschbaren Mikrocontroller und dem vielen Platz im Inneren noch weit mehr Möglichkeiten.

Der PicoCalc ist das Gerät, mit dem die Verbindung zwischen Programmcode eingeben und zu sehen was dieser macht, wieder so unmittelbar wird, wie es zur Zeit der programmierbaren Taschenrechner war. Und es ist vielleicht einer der momentan kultigsten Wege zu programmieren. Es geht darum Spaß am Lernen zu haben und das ist hier der Fall!

Alternativen

Bisher war ja mein Favorit zum Programmieren lernen der Pico-8, aber der ist halt, möchte man ihn ähnlich mobil haben, schon deutlich schwieriger zum Laufen zu bekommen, da man für ihn mindestens einen Raspberry Pi mit einem laufenden Linux benötigt. Dafür hat der Pico-8 dann aber auch die Möglichkeit mit seiner Mini-IDE Sprites zum Gestalten des Spiels sowie einen komfortablen Soundeditor zur Klangerzeugung zu verwenden. Ich habe ja in meinem Artikel ‚Clockwork uConsole – Der nerdigste Computer den ich jemals besaß‘ schon einmal beschrieben, wie ich die uConsole dazu verwende Pico-8 zu programmieren. Das funktioniert auch ganz gut, aber man muss dazu zuerst die uConsole starten, warten bis das Linux gebootet hat, Pico-8 aufrufen und kann dann erst mit dem Programmieren loslegen. Das geht mit dem PicoCalc schneller: Einschalten und schon kann man loslegen.

Im Vergleich mit der Oxocard Science, die gleichfalls elektronische Experimente als auch Programmierung anvisiert, aber die Programmierung nur über einen Browser zulässt, der dann auch noch auf einem anderen Computer laufen muss, bietet der PicoCalc bei weitem mehr. Mit ihm ist es möglich völlig ohne zusätzliche Geräte Programmieren zu lernen und auch mit Breadboard Schaltungen mobil zu sein. Das ist für Outdoor Anwendungen, bei denen in Echtzeit unterwegs am Programm gearbeitet werden muss, viel besser. Wenn man dann bedenkt dass eine Oxocard, je nach Version zwischen 40 und 100 Euro kostet, sind die 75 Dollar für den PicoCalc nicht viel Geld. Ok, mit allen Gebühren werden es wohl eher 100 Dollar.

Vorschläge für zukünftige ClockWork Geräte

Wie anfangs geschrieben wünsche ich mir schon lange eine Art ‚Super Programmierbarer Taschenrechner‘. Und da ist der der PicoCalc die bisher beste Implementation die ich je gesehen habe. Ich würde mir ihn nur noch ein wenig kleiner und dünner und mit einem fehlerfreien Keyboard wünschen. Es bräuchte auch keinen einsteckbaren Mikrocontroller, stattdessen darf der ruhig verlötet sein. Die Möglichkeit die Firmware anzupassen würde ich aber beibehalten, da man so aus dieser fantastischen Grundlage je nach Bedarf und persönlichen Wünschen ein individuelles Gerät machen kann..

Starke Konkurrenz für ein solches Gerät wäre für mich ein nativer Pico-8. Vielleicht basierend auf einem FPGA Baustein, der genau auf die Bedürfnisse des Pico-8 zugeschnitten ist. Aber auch eine dem Pico-8 ähnliche oder gar noch bessere Implementierung wäre ein fantastisches Lernmittel für die Programmierung. Was mir am Pico-8 gefällt ist die durch eingebauten Sprite-, Landschafts- und Soundeditor gegebene starke Vereinfachung der Programmierung von Spielen.

Tipps und Tricks

Hier findet man einige Basic Programme die unter PicoCalc laufen:

https://github.com/rlauzon54/PicoCalcBasic

Eine sehr gute Möglichkeit mit dem PicoCalc zu arbeiten ist die Entwicklungsumgebung MM Edit:

https://geoffg.net/mmedit.html

PicoCalc Dokumentation

https://github.com/clockworkpi/PicoCalc/tree/master/wiki

PicoMite Basic

https://github.com/clockworkpi/PicoCalc/blob/master/PicoMite_User_Manual.pdf

Extremkurz Anleitung

Standardmäßig wird die PicoMite-Firmware auf dein Gerät geflasht, dabei handelt es sich um einen einfachen BASIC-Interpreter. Du kannst den Editor öffnen, indem du ‚edit‘ eingibst. Speichern und schließen kannst du mit der Taste [F1]. Ausführen kannst du dein Programm mit dem Befehl ‚run‘ oder durch Drücken von [F2].

Den Inhalt der SD-Karte kannst du dir anzeigen lassen, indem du zuerst

drive "b:"

eingibst und danach

files.

Eine BASIC-Datei lädst du mit

load "mand.bas".

Deine BASIC-Programme speicherst du mit

save "name.bas".

Für Syntax Highlighting: OPTION COLOURCODE ON

Fuzix ist ein kleines UNIX-Betriebssystem.

MP3Player ermöglicht das Abspielen von MP3-Dateien.

NES ist ein NES-Emulator.

uLisp ist ein Lisp-Interpreter (damit lassen sich coole grafische Renderings erstellen). Es gibt einen Thread, der erklärt, wie man ein kleines Skript erstellt, mit dem sich Lisp-Dateien von der SD-Karte laden lassen.

Wie bringt man alternative Firmware auf den PicoCalc?

Das ist eigentlich ganz einfach. Zuerst von hier die ZIP Datei downloaden. Diese in einem beliebigen Verzeichnis auspacken. Dann den PicoCalc über seinen Micro-USB Anschluss (nicht den USB-C Anschluss!) verbinden. Gleichzeitig mit dem Einstecken des Steckers den kleinen weißen Taster, den man durch die Rückseite des PicoCalc auf dem Pico Board sieht, mit einem kleinen Schraubenzieher oder ähnlichem, drücken. Daraufhin erscheint unter Windows ein Fenster mit 2 Dateien. Jetzt aus der entpackten ZIP Datei eine der Dateien mit der Endung ‚uf2‘ aus dem Verzeichnis ‚..\PicoCalc-master\Bin\PicoCalc SD\firmware‘ in das Fenster kopieren. Daraufhin schließt sich das Fenster und die neue Firmware wird installiert. Achtung: Nicht die gleich klingenden Dateien aus dem Verzeichnis ‚..\PicoCalc-master\Bin‘ verwenden!!!

LoRa?

Sehr interessant finde ich die Möglichkeit einen LoRa Sender/Empfänger in das Gehäuse einzubauen und dann mit MMBasic anzusprechen um so Erfahrungen mit LoRa zu sammeln und Nachrichten senden und empfangen zu können. Ich denke das werde ich irgendwann einmal ausprobieren.

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

PicoVaders

Hier findet sich funktionierender MMBasic Code für eine Implementierung des Space Invaders Spielautomaten. Ich finde es zwar etwas langsam, aber es funktioniert und sieht dem Original sehr ähnlich. Aus dem Code lässt sich auch einiges über die Programmierung von Grafik auf dem PicoCalc lernen.

https://www.thebackshed.com/forum/ViewTopic.php?TID=14976

Beispielprogramme

Larson Scanner

Ich programmiere gerne aufwendige RGB Animationen für LED Ketten oder Panels. Da hat es mich sehr gefreut das MMBasic standardmäßig eine Funktion (DEVICE WS2812) zur Ansteuerung derselben beinhaltet. Das habe ich gleich einmal ausprobiert:

Einfacher Test mit 3 Grundfarben:

DIM b%(2)=(RGB(20, 0, 0), RGB(0, 20, 0), RGB(0, 0, 20)))
SETPIN GP28, DOUT
DEVICE WS2812 W, GP28, 3, b%()

Als das funktionierte habe ich meinen Larson Scanner in C++ für den Raspberry Pico in das MMBasic des PicoCalc umgesetzt. Viel Spaß damit:

' Knight Rider / Larson Scanner für MMBasic (PicoMite)
CONST LEDCOUNT = 8

DIM b%(LEDCOUNT - 1)  ' RGB-Werte der LEDs (WS2812)

DIM i%, position%, direction%, red%

direction% = 1       ' 1 = nach rechts, -1 = nach links
position% = 0        ' Start bei LED 0

DO
  ' Alle LEDs leicht abdunkeln
  FOR i% = 0 TO LEDCOUNT - 1
    red% = (b%(i%) >> 16) AND &HFF
    red% = red% * 0.4
    b%(i%) = RGB(red%, 0, 0)
  NEXT i%

  ' Aktuelle LED auf volle Helligkeit setzen
  b%(position%) = RGB(255, 0, 0)

  ' LEDs aktualisieren (GP28 direkt angeben!)
  DEVICE WS2812 W, GP28, LEDCOUNT, b%()

  ' Position für nächsten Schritt
  position% = position% + direction%
  IF position% = LEDCOUNT THEN
    position% = LEDCOUNT - 2
    direction% = -1
  ELSEIF position% < 0 THEN
    position% = 1
    direction% = 1
  ENDIF

  PAUSE 128
LOOP

Lunar Lander

Der Lunar Lander Spielautomat hat mich schon immer fasziniert. Es gibt davon sogar nur mit Zahlenwerten realisierten Implementierungen auf einem der ersten programmierbaren Taschenrechner, dem Hewlett Packard HP-29C! Ich habe versucht es auf dem PicoCalc mit Grafik umzusetzen. Auch wenn es noch etwas Feinschliff bedarf, so kann es für Euch ein Rumpf für eigene Entwicklungen sein. 

' MM Basic LunarLander mit sichtbaren ASCII-Art-Sprites (inkl. HUD & Treibstoffanzeige)
screenW = 320 : screenH = 320
' --- Farben ---
white = RGB(255,255,255)
yellow = RGB(255,255,0)
black = RGB(0,0,0)
' --- Physik & Grenzen ---
maxThrust = 3
gravity = 0.15
rocketW = 16 : rocketH = 16
thrW = 8 : thrH = 8
' --- Spielvariablen ---
Randomize Timer ' Initialisiert den Zufallsgenerator mit der aktuellen Zeit
x = 50 + Rnd * 220 ' Zufllige x-Position zwischen 50 und 270
y = 20 + Rnd * 80 ' Zufllige y-Position zwischen 20 und 100
vx = -0.5 + Rnd ' Zuflliger Drift zwischen -0.5 und 0.5
vy = 0
angle = 0
thrust = 0
fuel = 200
oldX = x: oldY = y
' --- Pattern-Arrays ---
Dim rocketPat1$(rocketH), rocketPat2$(rocketH), rocketPat3$(rocketH)
Dim thrPat1$(thrH), thrPat2$(thrH), thrPat3$(thrH)
Dim rocket$(3), thr$(maxThrust)

' --- ASCII-Art (3 Richtungen, 3 Thrust-Stufen) ---
' Rakete geradeaus
rocketPat1$(1) ="0000000110000000"
rocketPat1$(2) ="0000001111000000"
rocketPat1$(3) ="0000011111100000"
rocketPat1$(4) ="0000011111100000"
rocketPat1$(5) ="0000111111110000"
rocketPat1$(6) ="0000111111110000"
rocketPat1$(7) ="0000111111110000"
rocketPat1$(8) ="0000111111110000"
rocketPat1$(9) ="0000011111100000"
rocketPat1$(10) ="0000011111100000"
rocketPat1$(11) ="0000001111000000"
rocketPat1$(12) ="0000011111100000"
rocketPat1$(13) ="0000111111110000"
rocketPat1$(14) ="0000111111110000"
rocketPat1$(15) ="0000110000110000"
rocketPat1$(16) ="0000100000010000"

' Thruster 1 (klein)
thrPat1$(1)="00011000": thrPat1$(2)="00011000"
thrPat1$(3)="00011000": thrPat1$(4)="00011000"
thrPat1$(5)="00000000": thrPat1$(6)="00000000"
thrPat1$(7)="00000000": thrPat1$(8)="00000000"
' Thruster 2 (mittel)
thrPat2$(1)="00011000": thrPat2$(2)="00011000"
thrPat2$(3)="00111100": thrPat2$(4)="00111100"
thrPat2$(5)="00111100": thrPat2$(6)="00011000"
thrPat2$(7)="00000000": thrPat2$(8)="00000000"
' Thruster 3 (stark)
thrPat3$(1)="00011000": thrPat3$(2)="00011000"
thrPat3$(3)="00111100": thrPat3$(4)="00111100"
thrPat3$(5)="01111110": thrPat3$(6)="01111110"
thrPat3$(7)="00111100": thrPat3$(8)="00011000"

' --- Umwandlung der Patterns in Bitmap-Strings ---
For f = 1 To 3
rocket$(f) = ""
For row = 1 To rocketH
pattern$ = rocketPat1$(row)
For block = 0 To 1
byteVal = 0
For b = 1 To 8
byteVal = byteVal * 2 + Val(Mid$(pattern$, block*8 + b, 1))
Next b
rocket$(f) = rocket$(f) + Chr$(byteVal)
Next block
Next row
Next f
For t = 1 To maxThrust
thr$(t) = ""
For row = 1 To thrH
Select Case t
Case 1: pattern$ = thrPat1$(row)
Case 2: pattern$ = thrPat2$(row)
Case 3: pattern$ = thrPat3$(row)
End Select
byteVal = 0
For b = 1 To 8
byteVal = byteVal * 2 + Val(Mid$(pattern$, b, 1))
Next b
thr$(t) = thr$(t) + Chr$(byteVal)
Next row
Next t

' --- Hintergrund zeichnen ---
CLS
Line 0,screenH - 1,319,screenH - 1,,white
Box 150,screenH - 6,20,5,,white

' --- Hauptschleife ---
Do
HandleInput
UpdatePhysics
RenderFrame
Pause 33
Loop
Sub HandleInput
k$ = Inkey$: If k$ = "" Then angle = 0: Exit Sub
s = Asc(k$)
Select Case s
Case 130: angle = -1
Case 131: angle = 1
Case 48 : angle = 0
Case 128
If fuel > 0 Then
thrust = thrust + 1: If thrust > maxThrust Then thrust = maxThrust
End If
Case 129
thrust = thrust - 1: If thrust < 0 Then thrust = 0
End Select
End Sub
Sub UpdatePhysics
vx = vx + angle * thrust * 0.05
vy = vy + gravity - thrust * 0.1
If angle = 0 Then
vx = vx * 0.95 ' Dmpfung fr vx
End If
x = x + vx: y = y + vy
If fuel > 0 Then
fuel = fuel - thrust * 0.2
If fuel < 0 Then fuel = 0
Else
thrust = 0
Print @(120,100);"Fuel empty!"
Pause 2000: End
End If
If x < 0 Then x = 0: vx = 0
If x > 319 Then x = 319: vx = 0
If y < 0 Then y = 0: vy = 0
If y >= screenH - 10 Then
If Abs(vy) < 1 And Abs(vx) < 1 And angle = 0 And x >= 150 And x <= 170 Then
Print @(120,100);"SUCCESS!"
Else
Print @(140,100);"CRASH!"
End If
Pause 2000: End
End If
End Sub
Sub RenderFrame
Box oldX-rocketW/2, oldY-rocketH/2, rocketW, rocketH+thrH,,0,0
idx = angle + 2
GUI BITMAP x-rocketW/2, y-rocketH/2, rocket$(idx), rocketW, rocketH, 1, white, 0
If thrust > 0 Then
GUI BITMAP x-thrW/2, y+rocketH/2, thr$(thrust), thrW, thrH, 1, yellow, 0
End If
oldX = x: oldY = y

' --- HUD ---
height = screenH - y - 10
Box 0,0,140,50,,black,black
heightStr$ = Right$(" " + Str$(Int(height)), 4)
Text 5, 5, "H:", "LT", 1, 1, white, black
Text 65, 5, heightStr$, "RT", 1, 1, white, black
vyStr$ = Right$("" + Format$(vy, "%4.2f"), 5)
Text 5, 15, "V:", "LT", 1, 1, white, black
Text 65, 15, vyStr$, "RT", 1, 1, white, black
thrustStr$ = Right$(" " + Str$(thrust), 2)
Text 5, 25, "T:", "LT", 1, 1, white, black
Text 65, 25, thrustStr$, "RT", 1, 1, white, black
fuelStr$ = Right$(" " + Str$(Int(fuel)) + "%", 4)
Text 5, 35, "F:", "LT", 1, 1, white, black
Text 65, 35, fuelStr$, "RT", 1, 1, white, black
End Sub