And now some notes about how I got that far and that show the 6502 actually running some(one else's) code.

#picocomputer

https://emalliab.wordpress.com/2026/01/02/rp6502-the-picocomputer/

RP6502 – The Picocomputer

I picked up two PCBs for new retro-CPU computers for building over the holidays.

The picocomputer board was very kindly sent to me by Andy Piper who had just had five PCBs ordered and made, so had some spare. The Easy Z80 I sent off and had made myself, but I’ll come back to that one later. This post is about the Picocomputer.

The Picocomputer

So what is the Picocomputer? It is a minimal, but very functional, 6502 CPU single board computer that uses two Raspberry Pi Picos as supporting devices. Key features:

• W65C02 6502 CPU with W65C22 versatile interface adaptor (VIA) able to run up to 8MHz.
• 128K RAM, although only 64K is accessible I believe.
• VGA interface via one RPi Pico 2 running RP6502-VGA.
• USB CDC serial console via the RP6502-VGA.
• Boot loader and monitor, ROM loading, filing system, UART console, and USB host support for USB devices via the other RPi Pico 2 running RP6502-RIA. If a Pico 2 W is used there is also Wi-Fi networking and Bluetooth device support.

A major goal of the project is to allow a full 6502 environment without using any legacy (i.e. not widely available new) parts and without the constraints of a retro environment. As the author states in one of the development videos for the platform:

“Here’s a fun fact. This project was developed without any eproms or programmers for the 6502. I don’t own any and haven’t used them since the 1980s. And I have no regrets. That process is awful and I don’t need that kind of nostalgia.”

That pretty much sums up the philosophy of this project in a nutshell.

The project makes very effective use of the RPi Pico’s PIO and DMA which is one reason it is able to support an 8MHz 6502 and the design considerations are very well discussed in a series of videos here.

Key resources:

• Main documentation: https://picocomputer.github.io/
• Hardware build/availability notes: https://picocomputer.github.io/hardware.html
• Project Github: https://github.com/picocomputer/rp6502
• Video series: https://www.youtube.com/playlist?list=PLvCRDUYedILfHDoD57Yj8BAXNmNJLVM2r

There is a pretty active Github discussion area, Discord server, and community project wiki.

Sourcing and Building

Everything you need to know is described on the hardware page: https://picocomputer.github.io/hardware.html

As already mentioned Andy Piper generously sent me one of their spare PCBs, so I didn’t need to buy those, but all the files required are readily available to get your own built.

The hardware page walks through how to order the PCB and parts, or how to order an assembled unit directly from somewhere like PCBWay. There is a complete “how to order and build with no soldering” video here.

I used the provided “all parts” BOM file to order the components directly from Mouser, but I didn’t bother ordering a few of the common parts I already had kicking around. I did however keep the capacitors as it suggests axial 100nF and two ceramic 47uF capacitors, so I stuff with the recommended. Some of the resistor values seemed quite precise too, so I kept those in the order too.

There is a build video for the PCB here.

Note: you might have a 6502 and 6522 kicking around (I didn’t), but the BOM specifies the CMOS versions, 65C02 and 65C22 which are required to support 8MHz operation. It also requires 74ACxx support chips for the same reason, but all this is explained on the hardware page.

A Pico 2 W is optional, but is required if Wi-Fi and Bluetooth support is wanted. For my first version I’m using two Pico 2 non-W boards that I already have.

Building was relatively straight forward. The PCB has component references on one side and component values on the other. Personally, I’d have found it easier if the component values were on the main silkscreen side rather than the back. At least on the back, they are still visible once the components are in place. In the video (which I watched later) he checks the resistance of each resistor prior to power up the board for the first time, so having the resistance visible on the back makes that a very quick process.

There are two sets of debug pads under one of the Picos – these are not required for a working system.

I built it in the following order:

• Small capacitors. Being axial-type, these are smaller than resistors, so I did those first.
• Resistors. There are a lot of different values supporting the audio and video circuits.
• IC sockets (but not the Pico header sockets yet).
• Audio jack socket and reset switch.
• Large capacitors.
• Pico header sockets.
• Breakout header pins.
• VGA socket.

Hello World

I wanted a simple way to show it was running code on the 6502. In the videos there is an assembler “Hello World” so I figured that by pushing those same bytes into memory I’d be able to run that too.

Loading the code as a series of data bytes is fairly straight forward, once you have the data bytes. Just writing a series of addr then data statements, as follows:

0200 A2 00 B0 10 02 8D EE FF
0208 E8 C9 00 D0 F5 8D EF FF
0210 48 65 6C 6C 6F 2C 20 57
0218 6F 72 6C 64 21 0D 0A 00

But the “jmp” instruction referenced in the video to start the code doesn’t exist any more, the basic monitor program, whilst it can read and write to the 6502 rom “memory”, is actually designed to load and manage ROM files. In this context, ROM files are actually RAM images to be loaded into memory.

Even though the monitor lets me set the reset vector:

FFFC 00 02

Nothing seemed to happen. Then at some point I realised that writing to the serial port changed at some point during development and instead of writing to FFEE the RIA register for TX is FFE1. I changed that last EE FF on the first line to E1 FF. Whilst on the topic of changes, the “shutdown the 6502 and return to the monitor” instruction mentioned (FFEF at the end of line two) also seems to have gone, but I figured that probably wouldn’t matter…

But still nothing. The writing to FFFC doesn’t seem to be actually make it to the RP65020-RIA which manages the running of code via the “reset” command. Looking through the code for the monitor, it looks like both the plain memory writing and “binary” commands ultimately end up using ria_write_buf() function which appears to have special code for noticing when a write is destined for a RIA register, which looks like it includes the three vectors too, so everything should be working here. Note: I was pretty sure the bytes are stored in that order (00 02), but I did try both (02 00).

At this point I went off and found the online 6502 assembler that was used in the video and created my own version of the code as follows:

* = $0200
ldx #0
loop:
lda text,x
sta $ffe1
inx
cmp #0
bne loop
stop:
jmp stop

text:
.ASCII "Hello, World!"
.BYTE $0D $0A $00

Giving me the following bytes to use:

]0200 A2 00 BD 10 02 8D E1 FF
]0208 E8 C9 00 D0 F5 4C 0D 02
]0210 48 65 6C 6C 6F 2C 20 57
]0218 6F 72 6C 64 21 0D 0A 00
]FFFC 00 02
]0200
0200  A2 00 BD 10 02 8D E1 FF  E8 C9 00 D0 F5 4C 0D 02  |.............L..|
]0210
0210  48 65 6C 6C 6F 2C 20 57  6F 72 6C 64 21 0D 0A 00  |Hello, World!...|
]fffc
FFFC  00 02 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
]reset
Hello, World!

Now this actually works! This was pretty neat.

Thinking properly about it, after using the no longer supported “shutdown the 6502” instruction, the code must have just been flying off into who knows where and the text just wasn’t even making it as far as the serial port…

At this point I have to use PuTTY’s “Special Command -> Break” to get out of the infinite loop and return control to the monitor but that is fine when all I wish to do is to prove it is working and running code.

For reference, the memory map for the Picocomputer is as follows:

FFFE-FFFF BRK/IRQB vector
FFFC-FFFD RESB vector (reset)
FFFA-FFFB NMIB vector

FFE0-FFFF RP6502-RIA registers/vectors
FF00-FFDF 6522 VIA expansion
0000-FFF9 (not quite 64K) of addressable memory

There is no “ROM” as such, as already mentioned, the “ROM” is loaded into RAM on boot in order to allow it to run. If it includes a reset vector of its own, the RP6502-RIA understands this and can use it to run.

So that is where I went next.

EHBASIC

The community wiki has a lot of existing code to use, and one of them in a BASIC interpreter. The ROM file is available from: https://github.com/picocomputer/ehbasic/releases

I downloaded the basic.rp6502 file and stored it on a USB memory stick. The RIA pico can read from USB memory sticks if a micro-to-USB-B adaptor is used.

]ls
 11926 basic.rp6502
]install basic.rp6502
]help
Commands:
HELP (command|rom)  - This help or expanded help for command or rom.
HELP ABOUT|SYSTEM   - About includes credits. System for general usage.
STATUS              - Show status of system and connected devices.
SET (attr) (value)  - Change or show settings.
LS (dir|drive)      - List contents of directory.
CD (dir)            - Change or show current directory.
(USB)0:             - USB0:-USB7: Change current USB drive.
LOAD file           - Load ROM file. Start if contains reset vector.
INFO file           - Show help text, if any, contained in ROM file.
INSTALL file        - Install ROM file on RIA.
rom                 - Load and start an installed ROM.
REMOVE rom          - Remove ROM from RIA.
REBOOT              - Reboot the RIA. Will load selected boot ROM.
RESET               - Start 6502 at current reset vector ($FFFC).
MKDIR dir           - Make a new directory.
UNLINK file|dir     - Delete a file or empty directory.
UPLOAD file         - Write file. Binary chunks follow.
BINARY addr len crc - Write memory. Binary data follows.
0000 (00 00 ...)    - Read or write memory.
1 installed ROM:
BASIC.
]basic

52735 Bytes free

Enhanced BASIC v20240114

Ready
10 print "Hello"
20 goto 10
list

10 PRINT "Hello"
20 GOTO 10

Ready

It is possible to install several ROMs from a USB stick to the Pico and even set one of them to run automatically on boot.

Here I’m using PuTTY via the RP6502-VGA USB connection, but also have a small VGA display plugged in. The USB memory stick is plugged into the RP6502-RIA via an adaptor cable.

USB memory access seems quiet slow, but that could be my USB memory stick. I’ll have to experiment. But really, the fact that it is acting as a USB host at all seems pretty neat to me.

Conclusion

Well basically (pun not intended), it works and I can see that the 6502 is running code. I’ve not done anything to really exploit the VGA graphics yet or the 65C22 VIA peripherals and I’m still learning quite how everything is meant to fit together.

Next it would be really useful to get a development environment together to allow me to write some 6502 code, but for now, this seems like a really neat setup.

With the addition of a USB keyboard (possibly via a USB hub) this can function as an independent computer. I also have a Pico 2 W on the way, so at some point can try out the networking.

For now, I need to browse the discussion area, wiki and Discord and see what other people have been up to. The recently released OPL2 sound support sounds especially interesting…

Kevin

#6502 #picocomputer #rp2350 #rp6502

I appear to have a #picocomputer up and running...

Hoping to find a bit of time to build a couple of new computers over the next few weeks...

#PicoComputer #EasyZ80 #6502 #Z80

Got my #picocomputer all soldered up and ready to boot. This sucker is a retro hacker's delight. All the warm and fuzzies of some sweet #mos6502 development, none of the antiquated I/O to turn the nostalgia sour..

Got a PCB and all the parts to build the #picocomputer https://picocomputer.github.io/

I really like this take on a 6502 machine. All the fun and none of the annoying bits of a retro machine. And the developer has done quite a bit of work to make development on it fun too (vscode framework, support in cc65 and llvm)

Az önce Mastodon'da, karşıma "Picocomputer 6502" adında harika bir oyuncak hakkında toot çıktı!

YouTube Oynatma Listesine ulaştım ve hemen kendi kanalımın "Mikrodenetleyici Programlama" başlıklı Bölümünün içine Arduino Bilgisayarların önüne ekledim. ツ

Şimdi neymiş diye bütün yapım aşamasını izlemeye gidiyorum.

#RaspberryPiPico #Picocomputer
____
• Picocomputer 6502: https://www.youtube.com/watch?v=SVZaSRUhIjo&list=PLvCRDUYedILfHDoD57Yj8BAXNmNJLVM2r
• Mikrodenetleyici Programlama: https://www.youtube.com/@aslankemalaslan/playlists?view=50&sort=dd&shelf_id=8