MiST-Board mit frühem Archimedes-Core

In der Retro-Szene zeichnet sich seit ein paar Jahren ein neuer Trend ab: statt sich mit der uralten Hardware rumzuärgern, die langsam ihrem finalen Verfall entgegenstrebt, oder auf Emulatoren setzt, die es leider oft nicht schaffen das “originale” Gefühl herzustellen sondern irgendwie synthetisch wirken, setzt man auf “echte” Hardware auf FPGA-Basis und baut damit die alten Schätzchen nach.

Meines Wissens die erste breit eingesetzte Variante dieser neuen Spielart war der C-One, der eigentlich einen C64 nachbauen sollte, amüsanterweise aber als erste funktionierende “Personality” einen Amstrad/Schneider CPC-Core bekam. Nicht zuletzt deshalb, weil Original-Entwicklerin Jeri Ellsworth das kommerzielle Projekt C64 DTV (ein Joystick im Competition-Pro-Design, der einen kompletten FPGA-basierten C64-Nachbau enthielt nebst 30 klassischen Spielen und per FBAS direkt an einen gewöhnlichen Fernseher angeschlossen werden konnte) dazwischenschob.

Seit einiger Zeit gibt es nun das MiST-Board mit Zielrichtung eines Nachbaus von Commodore Amiga und Atari ST. Entscheidend: zwei Joystickports der Geschmacksrichtung “9polig Atari-kompatibel” – also die gute alte Microschalter-Digital-Generation, mit der sich die Kinder der 80er die Handgelenke bei Daley Thompson’s Decathlon oder Combat School ruiniert hat – sind mit an Bord. Software wird über eine SD-Karte bereit gestellt.

Und warum nun ein Artikel über das MiST-Board auf einem RISC OS-Blog? Seit kurzer Zeit steht eine früher Version eines Acorn Archimedes-Cores zur Verfügung, der einen 4MB-A3000 simuliert. Noch nicht wirklich ausgereift (keine Floppy-Emulation), aber ein guter Anfang. Hier kann man sich genau informieren.

Für schmale 200€ kann man das MiST-Board in einem recht schmucklosen Stahlblechgehäuse bei Lotharek (bekannt durch den  SD-Card-Floppy-Emulator HxC) kaufen. Wenn man sich überlegt, was gebrauchte gut erhaltene Atari STs, Commodore Amigas oder Acorn A3000 kosten, ein echtes Schnäppchen.

RPCEmu unter Linux – ein Kochbuch

Bekanntlich ist RPCEmu der beste frei verfügbare Emulator für IOMD-basierte Hardware (vulgo Risc PC und A7000), den es für die Geschmacksrichtung “Linux” gibt. Während es für die Windows-User ein “ready-to-install”-Paket gibt und auch ein ZIP-Paket, das man einfach irgendwo auf die Platte extrahiert, heißt es bei Linux traditionell “compile from source”.

Ich will hier für eine aktuelle Ubuntu-Installation kurz die Schritte skizzieren, die einen zu einem funktionsfähigen RPCEmu mit Netzwerkunterstützung führen – auf der RPCEmu-Seite sind die Hinweise doch etwas verstreut, und einiges muss man sich zusammenreimen.

Das verwendete RISC OS ist natürlich RISC OS 5 von RISC OS Open Ltd.

RPCEmu Quellcode beschaffen

Hier gibt es zwei Möglichkeiten: Sourcecodearchiv von der RPCEmu-Seite  herunterladen, oder per Mercurial direkt das Source-Repository anzapfen. Ersteres ist etwas komfortabler, weil im Archiv bereits viele Dinge unabhängig vom Quellcode an der richtigen Stelle liegen. Will man letzteres tun, muss man Mercurial (“hg”) auf die Kiste bekommen – der Paketmanager hält hier alles notwendige bereit (einfach “sudo apt-get install mercurial” ausführen geht am schnellsten). Auschecken des tip-Standes (anderswo “Head”, “Trunk” oder “Master” genannt) ist simpel:

hg clone http://www.home.marutan.net/hg/rpcemu rpcemu

Egal für welchen Weg man sich entscheidet, man sollte am Ende ein “rpcemu”-Verzeichnis auf der Platte liegen haben, in dem sich der Quellcode im Verzeichnis src befindet.

RPCEmu compilieren

Zunächst sollte man sein Linux mit den notwendigen Libraries ausstatten. Gott sei Dank sind die Abhängigkeiten hier überschaubar: es braucht nur Allegro (mindestens Version 4.2, aber nicht Version 5; derzeit aktuell ist 4.4) und pthread (aka libpthread). Letzteres war bei mir schon installiert, ersteres kam über “sudo apt-get install liballegro4-dev”.

Über das config-Skript parametriert man alle notwendigen Dinge, vor allem aktiviert man den dynamischen Recompiler (vulgo “JIT”), weil sonst die Emulation doch eher gemächlich läuft: ./configure –enable-dynarec

Danach kommt dann der eigentliche compile-Vorgang, den man wie üblich per “make” startet. Resultat ist ein Binary namens “rpcemu”, das theoretisch ausführbar wäre – aber es fehlt ja noch ein bisserl was.

RPCEmu vorbereiten

Hat man sich bei der Quellcode-Beschaffung vom Mercurial-Repository bedient, muss man etwas mehr tun. Dort, wo das rpcemu-Binary nun liegt, erzeugt man zwei Verzeichnisse: hostfs (dort liegt später das RISC OS-Dateisystem) und poduleroms (dort kommen RISC OS-Module rein, die RPCEmu dann automatisch ins ROM integriert, und zwar über den Podule-ROM-Mechanismus – genau so, wie z.B. bei physischer RISC OS-Hardware die Podules (Netzwerk, SCSI, IDE, USB…) ihre Treiber ins RISC OS einbinden). Ins poduleroms-Verzeichnis kopiert man jetzt die drei Dateien hostfs,ffa hostfsfiler,ffa SyncClock,ffa aus riscos-progs/HostFS und riscos-progs/SyncClock. Damit steht nun HostFS zum Booten zur Verfügung, und die RISC OS-Uhr wird regelmäßig mit der Uhr des Hostsystems abgeglichen.

Jetzt gilt es, die Konfiguration anzupassen. Das passiert in der Datei rpc.cfg. Damit unfallfrei gebootet werden kann, muss unbedingt
model = RPCSA
in dieser Datei stehen, da der “Dynamic Recompiler” zwingend die StrongARM-Emulation voraussetzt, ansonsten kommt es zu bösen Instabilitäten. Um für die spätere Netzwerkkonfiguration schon gerüstet zu sein, kann man hier schon die Zeile
username = <your standard username>
eintragen – den Platzhalter mit dem Benutzer ersetzen, der den Emulator später ausführen wird.

Alle anderen Konfigurationen – Sound aktiv oder nicht, wieviel RAM und VRAM etc. – kann man später bequem über das RPCEmu-Menü setzen (Strg+Ende blendet das Menü ein).

RISC OS installieren

Letzter Schritt ist die Installation von RISC OS. Seit RISC OS 3.5 ist RISC OS ja quasi zweigeteilt: einmal das ROM, und einmal die “disc based components”, auch gerne mal vereinfacht “!Boot” oder “Bootstruktur” genannt.

Das ROM bekommt man natürlich von RISC OS Open Ltd. https://www.riscosopen.org/content/downloads/riscpc – abenteuerlustige Naturen verwenden einen 5.21-Nightly Build, eher konservative Nutzer begnügen sich mit der als stabil gekennzeichneten Version 5.20. Beiden gemeinsam ist, dass man in den Tiefen des jeweiligen ZIP-Archivs fündig wird: soft/!Boot/Choices/Boot/PreDesk/!!SoftLoad/riscos ist die Datei der Wahl, die ins Verzeichnis roms des RPCEmu kopiert werden muss.

Passend zur ROM-Version braucht man jetzt noch das “HardDisc4”-Disk-Image. Hier https://www.riscosopen.org/content/downloads/common kann man das runterladen unter “Disc based components”. Um es nochmal zu wiederholen, weil Fehler hier oft sehr merkwürdige Auswirkungen haben – wichtig: passend zur ROM-Version! Ich empfehle die “self-extracting archives”, dann braucht man nicht extra noch einen Entpacker. Die Datei kopiert man nach “hostfs”, damit sie von innerhalb RISC OS zur Verfügung steht.

Jetzt ist es endlich soweit, und RPCEmu kann gestartet werden: einfach rpcemu ausführen. Standardmäßig ist im mitgelieferten cmos.ram ADFS als Bootdateisystem konfiguriert, deshalb kommt man nicht mal in den Desktop. Also schnell von der Kommandozeile in RISC OS konfigurieren:
*co. filesystem HostFS
Dann einfach
*desktop
tippen und man kommt in die graphische Oberfläche. Hier auf das HostFS-Laufwerksitem clicken, das vorher dort platzierte HardDisc4-File mit dem Filetype “Utility” ausstatten, doppelclicken und warten bis sich alles entpackt hat. Es entsteht ein Verzeichnis “HardDisc4” – den Inhalt dieses Verzeichnisses ins Root verschieben.

Netzwerk einrichten

Die Kür ist die Netzwerkinstallation. Die soll hier gar nicht im Detail behandelt werden, denn die RPCEmu-Doku ist hier sehr gut und erlaubt ein schrittweises Einrichten.

In Kurzform:

  • rpcemu künftig per sudo starten
  • per iptables und sysctl das Tunnelling konfigurieren
  • im RPCEmu-Menü das Netzwerk aktivieren (Strg+Ende, Settings -> Networking -> IP-Tunneling)
  • RISC OS-Netzwerktreiber installieren
  • RISC OS-TCP/IP-Konfiguration durchführen

Quellen

RPCEmu-Homepage http://www.marutan.net/rpcemu/
Linux compile from source http://www.marutan.net/rpcemu/linuxcompile.html
RPCEmu networking http://www.marutan.net/rpcemu/manual/network.html
Linux networking: binary config http://www.marutan.net/rpcemu/manual/net-lin.html
Linux networking: IP tunnelling http://www.marutan.net/rpcemu/manual/net-lin-tun.html
Networking: RISC OS network driver install http://www.marutan.net/rpcemu/manual/net-ro.html
Networking: RISC OS configuration for IP tunnelling http://www.marutan.net/rpcemu/manual/net-ro-tun.html

Der Expertentipp zum Abschluss

Wer wie ich mal probeweise die Linux-Maschine virtuell eingerichtet hat (z.B. via VirtualBox), sollte darauf achten, im BIOS die Virtualisierungsoptionen einzuschalten (VT-x, Intel VT, AMD-V oder ähnlich). Sonst ist die Performance eher unterirdisch, und man kann auch auf 64bit-Systemen nur 32bit-Gastsysteme betreiben.

 

Aemulor-Innereien

Adrian Lees, Autor von Aemulor (Pro) und Geminus, hat zwei Artikel ins Netz gestellt, die der eine oder andere vielleicht schon aus der Foundation RISC User kennt. Darin werden einige interessante Details zur Implementierung von Aemulor und Aemulor Pro beschrieben.

Wer die letzten zwölf Jahre unter einem Stein gelebt hat: Aemulor ist ein High-Performance-Emulator für 26bit-Software auf 32bit-only-Plattformen wie IYONIX pc, A9home, Raspberry Pi, BeagleBoard, PandaBoard und ARMX6. Aemulor Pro setzt noch einen drauf und bietet nicht nur eine Plattform für gewöhnliche WIMP-Anwendungen, sondern emuliert auch alles notwendige für Dateisysteme aller Art (Win95FS, LanMan98, CDROMFS) und bietet eine Emulation für sogenannte “low colour depth screen modes” – neuere Systeme fangen meist erst bei 8bpp an, während bis zum Risc PC noch alles bis runter zu 1bpp unterstützt wurde – und tatsächlich wurde das auch von Anwendungen wie Sibelius 7 verwendet.

Besonders zur Anfangszeit des IYONIX pcs war Aemulor beinahe unverzichtbar, weil die Konvertierung der Anwendungen von 26bit nach 32bit doch recht zäh war, und außerdem absehbar war, dass einige wichtige Anwendungen wohl noch eine lange Zeit nicht konvertiert werden würden (Impression-Familie, Artworks, Photodesk) – dass heute eigentlich bis auf Impression und Sibelius keine der “großen” Anwendungen mehr auf Aemulor angewiesen ist, sollte als positives Zeichen für die Plattform aufgefasst werden.

An dieser Stelle ein persönlicher Dank an Adrian Lees, der dieses Stück Software, das beinahe an Magie grenzt, über all die Jahre gehegt und gepflegt hat und den Nutzern der neuen Cortex-A8/A9-Plattformen kostenlos zur Verfügung stellt.

RISC OS-Projekte: ein kompetenter Browser

In der Reihe “RISC OS-Projekte” soll es um Anregungen gehen für Menschen mit zu viel Freizeit. Es sollen Projekte beschrieben werden, die sowohl interessant sind, technisch anspruchsvoll und mit hohem Mehrwert für die RISC OS-Community. Den Anfang macht quasi eines der größten denkbaren Projekte überhaupt.

Die Geschichte der Browser für RISC OS ist lang. Es begann mit ArcWeb und Webster im Bereich Freeware. Dann kam die lange Reihe an Versuchen, Browser zu verkaufen: Fresco (immer nur erhältlich im Gesamtpaket der ANT Internet Suite), Webite (als Teil von Termite Internet), WebsterXL, Acorn Browse, Oregano, Oregano 2. Ein kurzes Zwischenspiel gab es mit einer Portierung von Firefox 2, die aber recht langsam und instabil war und nicht wirklich in RISC OS integriert war. Aktuell ist nur einer übrig geblieben: NetSurf, der unter der GPL steht und ständig weiterentwickelt wird.

Das Problem: das Internet entwickelt sich weiterhin rasant weiter. HTML5 und CSS3 sind aktuell die Standards, dazu tiefe JavaScript-Integration zur DOM-Manipulation. Die ständig zunehmende Verwendung von komplexem JavaScript erfordert außerdem ausgefeilte Optimierungsmechanismen bei der JavaScript-Interpretation. NetSurf hinkt schon heute dem Stand der Technik weit hinterher und hat bis heute keine anständige JavaScript-Unterstützung. Die Ziele der NetSurf-Entwickler sind sicher weitgehend passend für RISC OS-Zwecke (speicherplatzsparend, schnell, kompakt, gutes schlankes UI), aber was hilft das, wenn moderne Webseiten schlicht nicht zugänglich sind? Das sollte nicht als Kritik an NetSurf missverstanden werden – die Entwicklerkapazitäten sind dort begrenzt, und der Wettlauf gegen die Aktualisierung der Standards ist kaum zu gewinnen ohne ein großes Vollzeit-Entwicklerteam.

Im RISCOSOpen-Forum gibt es dazu einen Thread mit einer recht interessanten Diskussion dazu.

Unterm Strich bleibt meines Erachtens nur eine sinnvolle Option: die Portierung von Firefox/Gecko oder WebKit/Blinks. Nur damit ist garantiert, dass der Browser anständig kompatibel ist und bleibt mit den aktuellen Inhalten des Webs. WebKit scheint rein vom Portierungsaufwand her die bessere Wahl zu sein – es ist die deutlich jüngere Codebasis, wurde schon auf viele auch spärlich ausgestattete Plattformen portiert, und scheint generell besser modularisiert zu sein als Firefox bzw. Gecko.

Also, frisch ans Werk. Es braucht jemand, der sowohl unter RISC OS als auch unter Linux zuhause ist. Jemand, der die UI-Toolkits unter Linux kennt und natürlich WIMP-Experte ist. Jemand, der C und C++ im Schlaf beherrscht. Jemand, der die notwendige Entwicklungsinfrastruktur aufsetzen kann und dann natürlich auch betreibt. Und jemand, der reichlich Freizeit hat, um das Projekt voranzutreiben. Mit anderen Worten: einer allein wird das wohl kaum schaffen.

Grobe Vorgehensweise: einen ausreichend leistungsfähigen Linux-Server anmieten. Die heutzutage notwendige Infrastruktur aufsetzen (Gerrit/Git, Jenkins, GCCSDK). Das WebKit-Git-Repo clonen. Die WebKit-Portierung finden, die RISC OS technisch am nächsten ist. Code branchen und anfangen, den technischen Minimaldurchstich zu implementieren (hier gibt es Hinweise dazu). Nach und nach die Lücken füllen – vermutlich wird es sinnvoll sein, einige der Mainstream-Libs zu portieren wie Cairo und Freetype. Die notwendigen Anpassungen für die RISC OS-Portierung als Patches upstream zur Verfügung stellen. Eine anständige RISC OS-GUI drumrumstricken. Herausfinden, dass WebKit inzwischen von Blink abgelöst wurde. Gehe zurück auf Los. Froh sein, dass man die Basislibs schon portiert hat.

Ein ironisch-sarkastischer Beitrag zum Browser-Thema findet sich hier. “Because there are four of you” könnte zum geflügelten RISC OS-Ausspruch werden. Das Original von Peter Naulls ist auch immer noch von gewisser Aktualität und zeigt, wie alt das “Browser-Problem” schon ist.

Bewegung im GCCSDK-Repository

Um halbwegs auf dem Laufenden bezüglich der GCC-Entwicklung der Geschmacksrichtung RISC OS zu bleiben, schaue ich ab und zu mal rein, was im SVN-Trunk von GCCSDK so läuft.

Seit ein paar Tagen gibt es interessante Commits von Lee Noar, der schon der Hauptverantwortliche für den RISC OS ELF-Support war. Die Schlüsselworte lauten Clang und LLVM.

Clang ist – compilertechnisch gesprochen – ein Frontend für C, C++ und Objective-C, das an die Compiler-Infrastruktur von LLVM angeflanscht werden kann. LLVM arbeitet dann als Backend, um den von Clang gelieferten Input in was Maschinentaugliches zu verwandeln.

Warum Clang/LLVM anstatt GCC? Die Clang- und LLVM-Codebasis ist deutlich jünger und übersichtlicher, die Weiterentwicklung ist sehr dynamisch, der Compilevorgang viel schneller und speichersparender. LLVM kann Bytecode erzeugen, der dann in einer VM ausgeführt werden kann – daher hat LLVM auch seinen Namen.

Wo sind die Haken? Der ARM-Codegenerator von LLVM ist wohl hauptsächlich auf ARMv6/ARMv7 optimiert. Die Portierung auf non-Unix-Plattformen gilt als eher schwierig. Die Details bezüglich EABI/APCS-32 usw. sind bisher eher unklar. Also zumindest mir 🙂

Übrigens kann GCC per DragonEgg so umgedingst werden, dass LLVM als Backend verwendet werden kann.

Mit dem Raspberry Pi drahtlos ins Netz

Wir RISC OSler müssen ja leider derzeit auf anständige (oder genauer: auf irgendeine) WLAN-Unterstützung in unserem Lieblings-OS verzichten. Aber wie so viele Softwareprobleme kann auch dieses durch Hardware erschlagen werden. Ich will im folgenden Beitrag solche Geräte vorstellen.

Die Geräte funktionieren natürlich nicht nur mit dem Raspberry Pi, sondern auch mit allen anderen RISC OS-Rechnern, die entsprechende Anschlüsse (Ethernet und/oder USB) aufweisen. Ich habe (noch?) nicht im Einzelnen geprüft, ob die Geräte alleine mit RISC OS-Mitteln konfiguriert werden können (das scheitert normalerweise an der fehlenden JavaScript-Fähigkeit der Browser) – nicht nur, weil ich nicht alle genannten Geräte besitze, sondern weil ich über das Stadium, ausschließlich RISC OS verwenden zu wollen, lange hinaus bin.

Sollte jemand Interesse an einem bestimmten Gerät haben, kann ich das auf Anfrage aber näher unter die Lupe nehmen.

Mit dem WLAN-Client ins WLAN

Unter einem WLAN-Client versteht man ein Stück Hardware, das einen Ethernet-Anschluss hat und quasi eine Bridge in ein beliebiges WLAN etablieren kann.

Kandidaten aus diesem Bereich:

 

Mit dem WLAN-Repeater ins WLAN

Eigentlich sind WLAN-Repeater dazu da, die Reichweite des heimischen WLANs zu erweitern. Es gibt aber Produkte dieser Kategorie, die nicht nur “repeaten” können, sondern zusätzlich einen Ethernet-Anschluss anbieten, um drahtgebundene Geräte mit ins WLAN integrieren zu können. An diesen Anschluss kann man natürlich auch einen Switch anschließen, um mehrere Geräte ans WLAN anzudocken.

Mit dem WiFi-Hotspot ins mobile Internet

Die Produktgruppe der WiFi-Hotspots erfreut sich seit einiger Zeit wachsender Beliebtheit. Der WiFi-Hotspot hat die Aufgabe, eine Verbindung ins Mobilfunknetz (möglichst über UMTS oder gar LTE natürlich) herzustellen und diese Datenverbindung dann über WLAN für interessierte Clients bereitzustellen.

Und da war bisher der Haken für uns RISC OSler: man konnte sich eben nur per WLAN verbinden. Jetzt habe ich aber ein Gerät gefunden, das zusätzlich noch einen gewöhnlichen Netzwerkanschluss anbietet: der Huawei E5730. Als zusätzliches Goodie ist das Teil gleichzeitig noch eine Powerbank mit 5200 mAh Kapazität – was gleichzeitig dafür sorgt, dass man den ganzen Tag vom Stromnetz unabhängig arbeiten kann. Zwei kleine Wermutstropfen muss man aber verkraften: es ist kein Anschluss für eine externe Antenne verfügbar (das ist sehr nützlich in ländlichen Gebieten oder im fahrenden KfZ), und es wird kein LTE unterstützt – dafür ist 3G mit DC-HSPA+ bis zu 42,2 MBit/s vertreten.

Bei den LTE-tauglichen Geräten habe ich keines gefunden, das mit einem Ethernet-Anschluss aufwarten kann. Dafür gibt es dann schicke Displays und manchmal sogar (micro)SD-Card-Slots zur Datenbereitstellung für die Clients, quasi als WLAN-Cardreader. Das ultimative Gerät, das all die schönen Features kombiniert, scheint es noch nicht zu geben.

Mit dem USB-Surfstick ins mobile Internet

Dank Thomas Milius und seinem COMCentre gibt es eine direkte Möglichkeit, USB-fähige RISC OS-Rechner ins mobile Internet zu bringen. COMCentre unterstützt verschiedene USB-Surfsticks wie z.B. den Huawei E173 oder K3765. Damit ein Surfstick mit COMCentre zusammen funktioniert, muss er über USB eine serielle Schnittstelle anbieten, über die dann COMCentre das Gerät quasi wie ein Modem in der guten alten Zeit ansprechen kann.

COMCentre kann man hier herunterladen.

Raspberry Pi 2 – Läuft bei mir

Zur Feier der Verfügbarkeit des Raspberry Pi 2 habe ich mir spontan einen bestellt. Die gute Nachricht: nur eine Woche nach dem Release der Hardware läuft RISC OS bereits problemlos drauf.

Kurzes HowTo für die Ungeübten:

  • microSD-Karte per SystemDisc vorbereiten
  • “Loader”-DOS-Image befüllen
    • Dateien von GitHub herunterladen
      • für die GitHub-Ungeübten: nicht direkt den Link zum Herunterladen nutzen, sondern auf den Link klicken und dann den “View Raw”-Link zum Herunterladen benutzen
      • man braucht die Dateien bootcode.bin, fixup.dat, start.elf
      • config.txt mit folgendem Inhalt dort erzeugen (vollständige Doku für Experimentierfreudige hier und hier):
        fake_vsync_isr=1
        init_emmc_clock=100000000
        kernel=riscos.img
    • RISC OS-Image herunterladen von RISCOSOpen Ltd
      • dort das Beta RPi ROM ZIP herunterladen (die Release-Version RC12a läuft nur auf den Vorgängermodellen)
      • aus dem ZIP die Datei riscos extrahieren und als riscos.img kopieren
  • Filecore-Teil der SD-Karte mit dem HardDisc4-Discimage (Nightly Beta, die Release-Version funktioniert nicht gescheit mit den neueren Beta-ROMs) von hier befüllen

Wie das früher ohne SystemDisc ging – keine Ahnung.

“RISC OS 944MB” lautet die Startup-Meldung. Cool.

Übrigens hat der Raspberry Pi 2 einen interessanten Zweitnutzen: wenn das Netzteil zu schwächlich ist oder dessen USB-Kabel für zu viel Spannungsabfall sorgt, wird oben rechts in der Ecke eine Art Regenbogen-Quadrat als Video-Overlay eingeblendet. Ich konnte dadurch ein paar Billigkabel aus meinem reichhaltigen Angebot direkt aussortieren.

 

Der Raspberry Pi 2 ist da

Die Raspberry Pi Foundation hat heute das Raspberry Pi 2 Model B angekündigt. Basierend auf dem BCM2836 sieht er seinem direkten Vorgänger, dem Raspberry Pi B+, täuschend ähnlich. Was gleichzeitig heißt, dass die alten Gehäuse weiterhin passen, ebenso wie das Peripherie-Zeugs. Preislich bleibt ebenfalls alles beim Alten.

Innendrin hat sich dagegen einiges geändert – das Herz ist nun ein Quad-Core Cortex-A7 mit 900 MHz, ein irrer Fortschritt gegenüber dem schon zum Erscheinungszeitpunkt veralteten 700 MHz ARM11 des Vorgängers. Das RAM wurde auf 1 GB aufgestockt. Performancetechnisch verspricht das einiges – selbst bei ausschließlicher Single-Core-Nutzung (bekanntlich für uns RISC OSler ein wichtiger Faktor) dürfte gut die doppelte Performance rausspringen.

GPU-technisch ist alles beim alten geblieben, VideoCore IV bleibt uns erhalten.

Interessant auch die Ansage, dass es eine kostenlose Variante von Windows 10 für den neuen RPi geben wird. Nach dem angekündigten Tod der Windows RT-Tablets ein interessanter Schritt von Microsoft – mal sehen, welche Zielgruppe hier angesprochen werden soll.

Für die Linux-Nutzer ist sicherlich interessant, dass jetzt ohne Handstände das Ubuntu-Zeugs drauf läuft, das ja bekanntlich seit einiger Zeit auf ARMv7 setzt.

RISC OS-technisch arbeiten die üblichen Verdächtigen am notwendigen Update. Wie man hört, werden zukünftige Images kompatibel zu allen Raspberry-Pi-Varianten sein.

Von der nackten Platine zum fertigen RISC OS-System

Früher – in der guten alten Zeit – war die Sache mit den RISC OS-Rechnern ganz einfach: man zahlte einen furchtbar hohen Preis an Acorn (oder später an STD, Castle, CJE, RiscStation, MicroDigital…) und bekam dafür ein Komplettpaket. Rechner im Gehäuse, dazu typischerweise Maus und Tastatur, manchmal sogar Handbücher und Software. Bei Acorn gab es in der RPC-Anfangszeit sogar mal ein Zwangsbundling mit Monitoren – was für ein Spaß.

Heute geht das zwar auch noch, wenn man sich denn von R-Comp einen ARMini(X) holt oder von CJE Micro’s einen PandaRO, aber erstens entfällt dann der Bastelspaß, zweitens sind die Preise durchaus anspruchsvoll und drittens kann man sich die Komponenten nicht selbst aussuchen. Ein Zwischending sind PIK und BIK von a4com, da kann man mit Detlef durchaus aushandeln, welche Komponenten es denn sein sollen, und die Preise sind auch nahe an den Selbstkosten.

Dennoch: Selbstbau ist die einzig wahre Alternative. Bleibt die Frage, welche Komponenten es denn sein sollen.

Egal ob Raspberry Pi B(+), BeagleBoard-xM oder PandaBoard (oder für die ganz mutigen: IGEPv5), folgendes sollte es schon sein (und viele Komponenten sind in einem typischen Nerd-Haushalt sowieso schon vorhanden und können so einer vernünftigen Nutzung zugeführt werden):

  • USB-Tastatur
  • USB-Maus
  • aktiver USB-Hub
  • SD- oder microSD-Karte
  • Gehäuse
  • Netzteil
  • Kabel

Dank der 4 USB-Steckplätze kann man beim Raspberry Pi B+ und dem BeagleBoard-xM zur Not auf einen USB-Hub verzichten, allerdings rate ich dennoch immer zu einem USB-Hub, weil er erstens die Nutzung eines schwächeren Netzteils für das Board erlaubt und zweitens es immer eine gute Idee ist, ein paar freie USB-Ports in petto zu haben – USB-Brenner, USB-Festplatte, USB-Speicherstick, USB-Soundkarte…entscheidend ist, dass es sich um einen aktiven Hub handelt, also einen mit eigenem Netzteil zur Versorgung des Hubs und aller angeschlossener Geräte.

Wichtig für einen reibungslosen Betrieb ist ein leistungsfähiges, stabiles Netzteil. Unzählige merkwürdige Phänomene vom instabilen Netzwerk bis zu kaputten Dateisystemen ließen sich schon auf defekte oder unzureichende Netzteile und sogar Kabel zurückführen. Ich empfehle als Netzteil USB-Ladegeräte, da diese inzwischen dank der modernen stromhungrigen Smartphones sowohl leistungsfähig als auch stabil und preiswert geworden sind. Für den Raspberry Pi B(+) braucht man dann ein USB-microUSB-Kabel (genauer “USB micro B”), für BeagleBoard-xM und PandaBoard ein USB-2,1mm Hohlstecker-Kabel (z.B. hier von Delock bei Reichelt.

Diese Konstruktion erlaubt es auch, den in der modernen Platinenrechnerwelt wegrationalisierten Power-Schalter durch Aus-/Einstecken des USB-Steckers zu simulieren. Bastler bauen sich einen kleinen Schalter auf den USB-Stecker.

Ein besonders edler Vertreter der Art “USB-Ladegerät” (inklusive des unabdingbaren Features “blaues Licht”) kommt von Innergie und liefert 3A (hier bei Reichelt), die etwas preiswertere Ausgabe von Goobay (hier bei Reichelt) sogar bis zu 4,2 A.

Wieviel Saft der Rechner tatsächlich braucht, hängt hauptsächlich davon ab, wieviel Strom über die USB-Ports gezogen wird. Tastatur und Maus sind genügsam, USB-Speichersticks oder gar USB-Festplatten und USB-Brenner ziehen oft sogar mehr als die eigentlich erlaubten 0,5A, weshalb letztere beide gerne per Y-Kabel angeschlossen werden wollen. Genau deshalb ist es ratsam, maximal Maus und Tastatur direkt an die Platine zu klemmen und den Rest über einen aktiven USB-Hub zu versorgen. Die nackte Platine ohne zusätzliche Gerätschaften braucht irgendwas zwischen 0,6A (Raspberry Pi B+) und 1,5A (PandaBoard ES).

Beim Gehäuse hat man entweder die Qual der Wahl (Raspberry Pi) oder findet kaum was passendes (BeagleBoard-xM, vor allem aber PandaBoard). Hier ein paar interessante Fundstücke aus dem Netz:

Was Mäuse angeht, sollte jeder seinen eigenen Vorlieben folgen. Leider gibt es fast keine RISC OS-optimierten Mäuse (also solche mit drei Maustasten, aber ohne Scrollrad) mehr. Da ich sowieso über meinen KVM-Switch mehrere Systeme mit einer Maus steuere und weder Windows noch Linux schmerzfrei ohne Scrollrad bedient werden können, benutze ich derzeit eine Logitech M500. Das Scrollrad kann hier per obenliegendem Schalter zwischen “rastend” und “nichtrastend” umgeschaltet werden. Wer eher das “Basis-Maus-Feeling” aus der guten alten Risc PC-Zeit hat, wird bei der Logitech RX250 für schmale 7 EUR fündig.

Um Tastaturen ist in den letzten Jahren ein regelrechter Hype entstanden. Die Wiederentdeckung der mechanischen Tastatur, ob für den Gamer oder den Vielschreiber, hat viel Leid bei den Mitmenschen ausgelöst, die plötzlich dem nervtötenden Klackern von Cherry MX Blue-Switches ausgesetzt waren. Sparfüchse nehmen weiterhin eher Membrantastaturen (z.B. vom Erzfeind Microsoft für 8 EUR, oder etwas hochwertiger von Cherry und flüssigkeitsfest für 20 EUR und sehr kurzem Tastenhub). Preislich sind nach oben fast keine Grenzen gesetzt: 60 EUR für das Cherry MX-Board 3.0 mit den fast lautlosen “Red”-Switches, über “Das Keyboard 4 Professional” für fast 200 EUR bis hin zur mit farbigen LEDs hinterleuchteten Corsair K95 können fast alle Wünsche erfüllt werden. Bei WASD Keyboards kann man schließlich sogar beliebig customizen, z.B. mit seinem Namen auf der Leertaste, oder auch das gute alte Archimedes-Feeling zurückbringen mit den roten Funktionstasten.

Zum Abschluss noch die notwendige SD-Karte. PandaBoard und Raspberry Pi verwenden die normalgroße SD-Karte, während Raspberry Pi+ und BeagleBoard-xM eine microSD-Karte brauchen. Aufgrund der erreichbaren Performance ist ein reiner SD-Karten-Betrieb nur beim Raspberry Pi(+) wirklich anzuraten – hier lohnt sich also eine schnelle und ausdauernde Karte wie eine Sandisk Extreme oder eine der besseren Transcend oder Samsung. Beim Beagle- oder PandaBoard würde ich eher zu einer USB-Festplatte als Massenspeicher raten, die SD-Karte dient dann nur zum Booten von RISC OS (und kann demzufolge auch sehr klein sein). Generell stehe ich aber USB-Sticks oder SD-Karten als Computerspeichermedium eher skeptisch gegenüber, da hatte ich schon zu viele Ausfälle.

Also: auf zum fröhlichen Rechnerbasteln.

ADFFS 2.47 beta – Retro-Gaming auf dem Raspberry Pi

Jon Abbott war die letzten Wochen nicht faul und hat gestern ADFFS 2.47 beta veröffentlicht . Es gibt noch ein paar Haken aufgrund größerer Umstrukturierungen im Bereich Codelets und Blitter, aber das sollte den abenteuerlustigen experimentalfreudigen RISC OS-Nutzer ja nicht abhalten. Schwerpunkt der Arbeiten ist gerade der Raspberry Pi, das geht etwas auf Kosten von OMAP3/OMAP4 und IYONIX pc.

Die Liste der Spiele, die nun auf dem Raspberry Pi laufen, wird immer länger. Für mich besonders erfreulich: Cannon Fodder, das inzwischen auch offiziell im Rahmen des JASPP veröffentlich wurde. Wer zufällig ein HowTo für Level 8.4 “In at the deep end” hat – ich wäre interessiert…derweil vergnüge ich mich noch mit Resogun auf der PS3.