Atom and Single Board retro-Computers

[gob33]

OLIMEX has opened pre-orders at 50€ for AgonLight2.
Due to Brexit, UK buyers cant place orders < 200€. You'll have to group by or find a local reseller.

Unfortunately, we currently cannot complete orders for the UK with value less than 200.00 EUR.
Due to Brexit and the new UK regulations, sellers sending goods under 200.00 EUR to UK require UK VAT ID and EORI registration in order to collect UK VAT in advance. We do not have such registrations and can't send small orders.

UPDATE: The PiHUT is UK reseller for AgonLight2 and metal case.

Comparison Olimex vs Original and tests.

The native software development framework for the ESP-32 is called the Espressif IoT Development Framework (ESP-IDF).
The ESP-IDF functionality includes menu based configuration, compiling and firmware download to ESP32 boards.
To develop applications for ESP32 you will need:

• A PC loaded with either Windows, Linux or the Mac operating system
• Toolchain to build the Application for ESP32
• ESP-IDF that essentially contains the API for ESP32 and scripts to operate the Toolchain (ESP-IDF v5.0 is a major update).
• A text editor to write programs (Projects) in C, e.g. Eclipse
• The ESP32 board itself and a USB cable to connect it to the PC

The quickest way to start development with the ESP32 is by installing a prebuilt toolchain:
Prebuilt Windows GNU Toolchain for ESP32

NOTE 1: That board or the next 50MHz version is perfect for an Amstrad CPC evolution. Old/Abandonned projects like:

• CPCng with OS-X/Zylix by Francis Görmacker (Unix like multitasking 8bits OS written in TML2) and NGBasic interpreter.
• Future OS
• SymbOS by Prodatron
• Retroleum EZ80P board

NOTE 2: Would be good to boot in a microkernel then launching a language interpreter and have a monitor and editor.
See for example André Fachat GeckOS/A65 v2.0, canadian Micrium µC/os II
Or read the 40k TinyCore 65c02 MicroKernel by Jessie Oberreuterhow on Stefany Allaire's Foenix256junior.

See also eZ80 related operating systems:
FreeRTOS port
Fuzix & wiki
There seems to be an obsoleted port of Apache NuttX for ez80.

NOTE 3: The eZ80 is underpowered face to the ESP32. The Espressif SoC do the most through the fabGL library, it is itself a true RT system (EEPROM+RAMs) which can run emulators (see the 6502 and 6522 fabGL classes). Im asking if the Maximite 2 with only a 32bits ARM Cortex-M7 480MHz would be superior with some BBC Basic instead of MMBasic (which is good).

NOTE 4: As the fabGL has already an embedded VIC20 emulator, it should be possible to make an Atom/BBC emu inside the library inspired by the VIC20 code. In fact, the eZ80 is here for the slow 8 bits concept, but could be totally ommitted if BBC emulation is done directly in the FabGL on the ESP32 (for ex. the FabGL developpement board has all I/O to experiment that or the LilyGo® TTGO VGA32). ESP32 runs internally FreeRTOS and classes for 6502 and 6522 are already in FabGL, can Dean Belfield's code be ported inside FabGL instead of calling outside from eZ80 ? This is internal emu on 32 bits.

The Raspberry Pi Pico BBC Basic by Memotech-Bill could be a good start for developping an ESP32 version.

Agon LIght Forum

[scruss]

... the Maximite 2 with only a 32bits ARM Cortex-M7 480MHz would be superior with some BBC Basic

Sadly, that model of M7 is effectively unobtainable, hence why the Maximite II is off the market. It's a phenomenally powerful chip.

It would be very challenging porting ARM BBC BASIC V (/ VI ?) to the M7 because of the difference in instruction sets

[gob33]

The AESIR is a microcomputer project by Kyle Cardoza (Studio 8502) similar in spirit to the Agon Light.
But a WDC W65C265S CPU @ 12Mhz (16Mb linear address space) replaces the eZ80, two ESP32-PICO-D4 are used (one handles the keyboard, dual SDHC FAT32 cards and generates audio using an external I2S DAC, the other is dedicated to the graphics system through FabGL), an ATF1502 CPLD for the glue.
Unlike the Agon, where their sole ESP32 is connected to their eZ80 via serial, in ÆSIR the two ESP32s are wired to the Parallel Interface Bus, a byte-wide "coprocessor" focused bus unique to the W65C265S.

ESP Audio library

NOTE 1: The W65C265S has the full 24-bit address and data bus available as opposed to the W65C816S having the high order 16-23 address pin multiplexed with the data bus. The Parallel Interface Bus (PIB) is used to communicate instructions and data to and from task oriented
processors, smart peripherals, co-processors, and parallel processors.
The W65C265S better corresponds to the usage of BBC Basic + Assembler than the eZ80 by assuring 6502 compatible mode.
W65C265S 8/16-bit micro-controller Datasheet

NOTE 2: Kyle Cardoza said (2023/04/22)

Yes, the rumours are true: A 6502-family Agon is, indeed in the works. How do I know? I'm the lead on the hardware.
It's called Agon 65X. It uses the same VDP as the classic Agon, but the CPU is a Wester Design Center W65C265S, clocked at 8MHz. It has 512KB of SRAM and 512KB of flash ROM, SD card, the same graphics capabilities as the eZ80 Agon boards, and features two SNES-compatible gamepad ports and a 24-pin GPIO "User port" with ten GPIO pins and an SPI connection.
It runs a custom, 65816 native mode kernel called Esper 65X, written in assembly language and C99 by myself; it does not run BBC BASIC, and will not unless someone else wants to do that port, in which case I will happily and gratefully include it in the ROM image on release.
You will be able to code for it initially with cross-development using the free Calypsi 65816 C99 and assembly toolchain. As the software ecosystem develops, we will gain on-hardware native development tools.

[scruss]

Unlike the Agon, where their sole ESP32 is connected to their eZ80 via serial, ...

Eep! You're right. I thought at least they'd have gone with something faster and synchronous like SPI, but nope — the ESP32 is hanging off the Agon Light 2's EZ80 UART. There seems to be flow control lines enabled, but that's one way of doing it, I guess.

[gob33]

The LilyGo® TTGO VGA32 v1.4 is a very low price board with an ESP32 which can be used for 8-bits emulation.
520 Kb of RAM is available, but since it is shared with the Free RTOS Operating System and all the modules (WIFI, serial, bluetooth), only 300 Kb is available and in a special way.

• Memory: The 520 Kb is shared with all modules and the Free RTOS Operating System. If we run out of memory, the ESP32 throws an exception and resets itself. If a malloc is used, and there is no memory, it automatically restarts. The best trick is to do as when games were developed in the 90's, that is, all the memory is reserved at the beginning and then we use it. There is memory fragmentation, so we cannot take all the memory we want, since due to the size limit (fragments), even if there is free space, that size is not available. Therefore, the ideal is to use reduced fragments (no more than 16 Kb). If a free fragment is not available, reset (watchdog). We can remove modules (WIFI, serial, bluetooth), and unnecessary things to save memory.
  IRAM memory, ie code memory, is available. Although the manufacturer speaks of 180 Kb, it is usually 96 KB at most and falls within the shared 520 Kb. This type of RAM would be for local variables and code arrays. If we run out of IRAM, the compiler normally notifies us, but otherwise, the ESP32 is reset. It is the fastest, since it is cached.
• Memory speed: This is older than breathing, and it occurs in most microcontrollers, but I'm going to order from fastest to least, the speed of the different types of memory in said microcontroller:
  • IRAM : 96 Kb cached within the 520 Kb of SRAM.
  • RAM : All other SRAM up to 520Kb other than IRAM.
  • PSRAM : external RAM module. It can be added, but the base plate comes without it.
  • FLASH : 4 Mb aligned to 32 bits (4 bytes), that is, if we insert 1 byte, if we do not compact, we will lose 3 bytes. For single byte readings, we must unpack (slower). Data (arrays) are placed here with the PROGMEM command. The code always goes in FLASH.
  • EEPROM : 512 bytes
  To give us an idea, if we read 16 Kb from a buffer (array) in FLASH, it will take around 800 microseconds. On the other hand, if we do it from RAM, depending on whether we do it in IRAM or not, we will move between 1 and 4 microseconds. So we have to have a global vision of what we want to do, and then in what type of memory we want to place the data, and think about whether we want to save speed or memory.
• DMA: There is 32-bit DMA, but it requires a 32-bit declaration and a specific way to access, specifically, to achieve microsecond accesses, to achieve access cache, with maximum requests of 4 Kb.
• Cores: Tasks can be created, but there is only one core.
• Modules: The use of modules and libraries not only results in the consumption of RAM, but also of FLASH, specifically if we use WIFI and GET HTTP requests, 70 Kb of RAM and 400 Kb of FLASH are consumed. If we have less than 70 Kb of free RAM, the ESP32 will reset itself. We can use smaller libraries, but they are not standard and cause problems.
• Porting emulators: You have to download the emulator, adapt it to low resources such as ESP32, do bypass for VGA32 and bypass to test on PC and watch later. If SDL or similar is used, it's easier. If the resolution is not very high, you can output to text mode.

After a rapid search, I got a list of emulators for the LilyGo® TTGO VGA (notably an Elektron emu):

As of 2023/02/08:

• ZX ESPectrum IDF ZX Spectrum emulator for TTGO VGA32 without PSRAM made by @Eremus (Víctor Iborra) https://github.com/EremusOne/ZX-ESPectrum-IDF . Supports multicolor, Bifrost*2, Nirvana and Nirvana+, Border effects, Contended memory, Contended I/O. Allows simultaneous SPIFFS and SD. It's accurate cycle.
• Elkulator (Acorn Elektron) Port by ackerman from x86 Tom Walker v0.5 for TTGO VGA32 v1.2 without PSRAM, single core, DAC 3 bits (8 colors) https://github.com/rpsubc8/ESP32TinyElkulator
• Vectrex Port made by ackerman from x86 John Hawthorn to TTGO VGA32 1.x without PSRAM, single core and WIFI support. Requires fabgl 1.0.8. https://github.com/rpsubc8/ESP32TinyVectrex
• NES Port made by ackerman from Jens Nyberg's PC NES Master (TTGO VGA32 1.x) without PSRAM and only one core. https://github.com/rpsubc8/ESP32TinyNesMaster
• Forth Computer Computer running FORTH natively (TTGO VGA32 1.x) without PSRAM, in the style of Jupiter ACE, created by Pablo Hugo Reda. https://github.com/phreda4/esp32-forth-computer .
• MCUME ZX81 VGA bypass made by ackerman from the MCUME ZX81 to any ESP32, even single core and TTGO VGA32 v1.x (1.0, 1.1, 1.2, 1.4). It uses a minimal version of bitluni converted to C (based on Ricardo Massaro's). It does not need PSRAM or SD. https://github.com/rpsubc8/ESP32TinyMCUMEesp81
• Fake86 Port made by ackerman of fake86 to any ESP32, even single core and TTGO VGA32 v1.x (1.0, 1.1, 1.2, 1.4). It uses a minimal version of bitluni converted to C (based on Ricardo Massaro's). It does not need PSRAM or SD. https://github.com/rpsubc8/ESP32TinyFake86
• Fairchild Channel F Port made by ackerman from FreeChaF to any ESP32, even single core and TTGO VGA32 v1.x (1.0, 1.1, 1.2, 1.4). The sound can use any digital pin of the ESP32. It uses a minimal version of bitluni converted to C (based on Ricardo Massaro's). It does not need psram or SD, it supports WIFI. https://github.com/rpsubc8/ESP32TinyFairChild
• CP/M Modification of @GuidoL https://github.com/guidol70/RunCPM_VGA32
• RC2014 ESP32Z80 V2 RC2014 emulator by @GuidoL. It is based on David Bottrill's RC2014-Emulation. https://github.com/guidol70/RC2014_ESP3 ... ator_VGA32
• C64: Port of Toy C64 emulator by ackerman from PC x86 (Rink Springer) to TTGO VGA32 v1.2. It is a test version, very basic, for now. https://github.com/rpsubc8/ESP32TinyC64
• Chip 8 emulator: I've finished porting Spittie's Chip8 emulator to PC. https://github.com/rpsubc8/ESP32TinyChip8
• AMSTRAD CPC Emulator: Port of Tom Walker's PC emulator by ackerman CPC 464, 664 and 6128. https://github.com/rpsubc8/ESP32TinyCPC
• VIC20 emulator: Fabrizio Di Vittorio's vic20 emulator https://github.com/fdivitto/FabGL Allows you to load PRGs from Flash or copy from a URL with WIFI connection to Flash.
• ALTAIR 8800 emulator: Fabrizio Di Vittorio's Altair 8800 emulator https://github.com/fdivitto/FabGL
• ZX-ESPectrum: In ZX-ESPectrum.ino there is a license comment, but it doesn't matter (they forgot to remove it), it's 100% free (confirmed by ramp). https://github.com/rampa069/ZX-ESPectrum Spectrum 16/48 works without PSRAM, and Spectrum 128/+2/+3 works with PSRAM. It supports SNA snapshots, ROMS, read and write tapes, and has an OSD. You need to activate the Huge App 4 MB partition, remove the PSRAM option at compile time, as well as use the FABGL macro and a single core. Pins 1 (serial communication) are used for the AY-3-8910, 26 (EAR_PIN pin 34) for tape input, and 27 (MIC_PIN pin 0) for tape output. Therefore, the mouse connector pins are being used, that is, an adapter must be made to use these extra features.
• ZX-ESPectrum Wiimote: Fork by David Crespo with mods by @Eremus based on the ZX-ESPectrum ramp. The correct pinout for the TTGO-VGA32 board (sound 25) is already defined in hardware.h. It has support for the WII controller and allows loading SNA,Z80 from the OSD. Supports the Jose Luis Sanchez core, accurate cycle, tape loading and multicolor. Only 48K mode works on TTGO VGA32 v1.2. 128k mode requires PSRAM. https://github.com/dcrespo3d/ZX-ESPectr ... ttgo-vga32
• Tiny ZX-ESPectrum without PSRAM: Fork by David Crespo and @rampa, by ackerman https://github.com/rpsubc8/ESP32TinyZXSpectrum Supports .SCR, loading BASIC and screens from .TAP, kempston mouse support, AY8912 sound emulation , tape pulse output per speaker, and runs on ESP32 without PSRAM, allowing 48K and 128K modes. Allows uploading SCR and SNA from web server over WIFI in 48k mode.
• Jupiter ACE ROM Emulator: Using a modified Paul Farrow ROM, the ZX 48K becomes a Jupiter Ace. It's not an exact emulator, but it does the main thing. It works on ramp069's ZX-ESpectrum, the wiimote, and the version I modded. Just rename the rom file to 0.rom or convert the file to .h and put it in the 128K section, because it makes use of bank switching. https://k1.spdns.de/Vintage/Sinclair/So ... 20Farrow)/
• ZX80 ROM emulator: Same concept as the Jupiter ACE. https://k1.spdns.de/Vintage/Sinclair/So ... 20Farrow)/
• ZX81 ROM emulator: Same concept as the Jupiter ACE. https://k1.spdns.de/Vintage/Sinclair/So ... 20Farrow)/
• Classic Gameboy: Fork of the lualiliu emulator by ackerman. https://github.com/rpsubc8/esp32gameboy . The roms have to be coded, compiled and uploaded. I have left 2 homebrew roms Retroid and Last Crown. Created the tool to put the roms in the project. https://github.com/rpsubc8/esp32gameboy ... uino/tools

All about the ESP32: The Internet Of Things with ESP32

[gob33]

OLIMEX is lauching a new board: the ESP32-SBC-FabGL is some sort of TTGO VGA or an half Agon Light.
It is the continuity of the fabGL dev board by Fabrizio Di Vittorio himself.
Proof you can emulate 8-bits directly on the ESP32 without overload.
But could the board be linked to a old computer ? I dont know.
15€ in June 2023

[gob33]

The ESP32-SBC-FabGL board will be available near June 15, but it has already been tested with RunCPM 5.7 and 6.0, TinyCPC Amstrad, TinyNes, TinyMCUME.
It will run runs all repositories made for FabGL and TTGO VGA32 (see post above) without any modifications or with small definitions.
OLIMEX board has also been connected as serial terminal through Access Bus to a Mensch W65C265 dev board giving VGA display and PS2 keyboard.

[gob33]

Retro-computing enthusiast "Rumbledethumps" has built the interesting RP6502 Picocomputer, a board using a CMOS 6502, 6522 and 2 x Raspberry Pi Pico.
You buy the board at PCBWay and mounts components without solding. Very simple.

Building a Pico 6502 computer kit and setting up Windows VScode environment. by lee smiths.
Project site and discussion forum.

I think it should be possible to replace the pico boards from Raspberry Pi Ltd by enhanced RP2040 boards from other manufacturers to get more capabilities like VGA resolution:

• WeAct Studio RP2040 (250MHz - USB-C - 2,4,8,16 Mb)
• zeankun.dev's Pico2040

It is in the same category as OLIMEX Neo6502 with 1 RP2040:

[marcusjambler]

Retro-computing enthusiast "Rumbledethumps" has built the interesting RP6502 Picocomputer, a board using a CMOS 6502, 6522 and 2 x Raspberry Pi Pico.
You buy the board at PCBWay and mounts components without solding. Very simple.

Building a Pico 6502 computer kit and setting up Windows VScode environment. by lee smiths.
Project site and discussion forum.


RP6502 pico computer.png

I'll take a PCB if someone decides to get some cut

Marcus

[gob33]

The pico-computer full kit is available at the Australia guy who sells Agon too.
Or search in the discussion forum someone who has ordered 2 or 5 pcbs.

[gob33]

Don Superfo, a guy who created several ZX Spectrum clones, has issued a new FPGA board "XBerry Pi", compatible with the Spectrum Next. Its format is the same as the Rasp Pi, has full connectivity and complete I/O, but also can run alternates cores through the SPARTAN-6, notably an Atom core here.
BeebFPGA should go too.

Available at zxrenew.co.uk.
Stardot thread

[gob33]

Tsvetan Usunov.jpg (9.29 KiB) Viewed 1604 times

OLIMEX Tsvetan Usunov says:

OLIMEX Neo6502 is a computer with real W65C02 connected to RP2040 co processor which takes care for everything else: emulates the memory, interfaces the USB keyboard, interfaces to DVI/HDMI monitors, play sounds and music, drive spirits and graphics, interfaces external USB flash drive and have I2C, SPI, UART, GPIO. So Neo6502 thinks it have real peripherals attached, while this is all emulation.

What makes Neo6502 modern is the possibility to use modern displays and TVs, Normal USB keyboards and Flash drives.
On top of this it has access to modern interfaces like I2C and SPI which allow it to interface modern sensors, displays and other devices unleashing the Arduino like applications.

With such flexibility was just matter of time to recreate all retro computers based on 6502 like Apple ][+, Apple IIe, Oric Atmos which are already done. Commodore64 and BBC Micro are in the TODO list.
What makes more fun is that you dont have to just copy what was done, but you can make your own unique arhchitecture as well, with the flexibility Neo6502 presents you can make your own dream 6502 computer.

The Neo6502 repository.
The Neo6502 Apple][+ Apple][e OricAtmos repository.
The Neo6502 original firmware from Paul Robson.
The Neo6502 BBC/EHBasic firmware from Rien Matthijsse
The Neo6502 environment by Oliver Schmidt
The Neo6502 Facebook group.

About the Neo6502, Paul Robson says;

The board itself has a max 8Mhz 65C02, an RP2040 and a 2Mb Flash chip together with hardware interfaces - USB host, buzzer, UEXT connector (an Olimex standard connector for expansion boards), HDMI socket.

What the machine spec is depends on the software loaded to it! 800x600 is used in the Apple/Oric emulators. 640x480 is used in Neo basic.
So Veselin's emulators are the same spec as their host machines. The "Retrocomputer" has its own spec ; graphics are 320x240x256 colour (with a palette), 53x30 text at the moment. The design is like the old Japanese machines where the machine is almost entirely RAM and you load BASIC into it - I had a Sharp MZ80K - except you don't do it from cassette tapes .

The 65C02 is currently working reliably at 5.6Mhz - clocked by the RP2040 and may go faster, but 8Mhz is probably out of reach. It seems faster in BASIC because things 6502s are bad at, floating point and 32 bit multiply and the like, are offloaded to the RP2040.

All the 65C02 RAM is for program code, graphics are stored elsewhere. (I haven't really considered it, but there's no reason why you couldn't write ARM Thumb code and run it on the RP2040 as well)

The limitations are sound, which is a beeper single channel, and you can't directly access hardware.
However, drawing sprites or tiles, or lines, or circles, RP2040 code is way way quicker than 65C02 code doing the same thing.

An example of speed up can be seen on the benchmarks. BM8 is 5 times quicker than the ARM2 based Archimedes, and about 30 times quicker than they Agon which has a faster processor. The reason is that this benchmark is sin, log and power testing. All the other machines do it using polynomial approximations on their CPU. Neo6502 uses the routines built into the RP2040 which are much much quicker. I hope to get similar speed benefits (perhaps not quite that much !) in other areas. Similarly, the RP2040 does all the floating point arithmetic and a fair chunk of the integer arithmetic.

cf: The Sorbus Computer

REM: If all is emulation on the RP2040 attached to a real 65C02, why not reversing the concept: take a full Pi 4 or 5 platform and emulate the 6502 in a virtual machine ?

[gob33]

Inspiration for a future Acorn case:
All that's left to do is design a case resembling the Master 128 with a PC keyboard accepting RC2014 vertical cards...

[gob33]

OLIMEX is now selling the bi-processor Z80 + W65C02 64Ko = CERBERUS2100 at 220€:
For those interested, the Hardware Manual describes well the board.