My favorite era of computing was the 1980’s, a decade that saw countless different machines produced, new technologies created, and what seemed like a non-stop torrent of advancements being made. It was an exciting time to be alive and the decade that I first got into home computing. While many of the computers of the era were incompatible with each other, one thing most of them had in common was they used some form of the BASIC programming language, often a customized version for the specific machine it was running on.
Beginners' All-purpose Symbolic Instruction Code (BASIC) is a high-level programming language that was relatively easy to learn and use and quickly became synonymous with the 1980’s. A high-level language, to put it simply, means it sits on top of other layers of code between itself and the hardware, and commands entered in high-level are passed through those other layers so it can be translated into something the hardware understands.
High-level languages, like BASIC, are much easier to understand on a human level than machine code, but since they have to pass through those other layers and be translated into code the machine can use, they're slower to execute becasue that process uses up valuable CPU cycles. On modern hardware, that's not really an issue thanks to the incredible power of modern processors, but on 80's hardware, there was a very noticeable difference in performance between something coded in BASIC verses something coded in a language like Assembly, a low-level programming language that is intended to communicate directly with a computer's hardware and thus executes much faster.
Microsoft BASIC was the foundation for most of the BASIC versions that came with the home computers of the era. It was also Microsoft’s founding product and was first released in 1975 for the Altair 8800 as “Altair BASIC”. When you powered up most home computers of the late 70’s and early 80’s, they loaded right into a BASIC or some other form of prompt, and from there you could enter commands, or in most cases, just start programming.
Of course, today things are vastly different, but I still have a soft spot for the BASIC programming language since it was the first language I ever learned. Fast forward to 2024 and outside of the retro community, it’s pretty much a dead language, however versions of it are still being made and available for people to use in their retro projects, and one such version is MMBASIC.
MMBASIC is open source, generally backwards compatible with Microsoft BASIC, and was originally created for the Maximite, a retro 80’s style self-contained computer designed by Geoff Graham. By the time I learned about the Maximite computer, it already had a couple different versions, and all of them were virtually impossible to find. Unfortunately for me, I really wanted one to play around with, and my hopes of a restock were further dashed when the world went crazy for a couple years.
Then, something cool happened, Geoff Graham ported MMBASIC to run on the Raspberry PiPico! This meant it was now possible to create an MMBASIC powered retro computer using a Raspberry Pi Pico as the core, enter the cool little “PicoMite VGA”. A boot-to-BASIC self-contained computer with 16 color VGA graphics and sound capability reminiscent of the early 1980’s. The best parts are, it’s very simple to setup and build and you can modify it however you want to fit whatever vision you have. So, that’s exactly what I decided to do, twice!
Geoff's PicoMite VGA Project: https://geoffg.net/picomitevga.html
I want to build my own version of the PicoMite as well as one based on someone else’s PCB design, both I could use to play around in MMBASIC and create a couple cool retro computers in the process. Something that can sit on my shelf next to the Z80-MBC2 based homebrew computer I had made earlier. I had already all the parts I needed for these builds on hand, all I really needed were cases to put it all in once I had it all built.
The first PicoMite I decided to build, and the focus of this post, was the Land
Boards PCB version because it looked like it would be the quickest and
easiest to get done. Unfortunately, that build got hung up for a few
days thanks to a faulty SD card slot that had initially tested
good and causing me a lot of headaches. Thankfully, when it was finally replaced during the troubleshooting
process and turned out to be source of my problems, I was able to get my first PicoMite VGA complete!. Below are all the links necessary to build this version of the PicoMite!
LandBoard PCB: https://www.tindie.com/products/land_boards/raspberry-pi-pico-card-with-vga-sound-kbd-v3/
Build Instructions: https://land-boards.com/blwiki/index.php?title=PiPicoMite03
My Customized End Plates: https://www.thingiverse.com/thing:6566451
The “DIY” build I plan on doing next, something I will cover in a new post later on, was inspired by a
video from the YouTube channel “Explaining Computers”, where they
did something similar and created their own version of the PicoMite
on a single solderable breadboard. I'll be taking a similar approach,
but using whatever I need to fit my design. You can check out their build linked below.
Explaining Computers PicoMite DIY VGA: https://www.youtube.com/watch?v=kZaWYgIYgd8
Once I had the LandBoards PCB on-hand, it was just a matter of soldering all together, with that minor hiccup caused by a faulty SD slot I had to replace. After I had the PicoMite up and running, all I had to do was 3D print some end covers for the aluminum enclosure that I modified to fit my taste, give the case a little flare, and put it all together. The end result if what you see below, a tiny little cool looking MMBASIC computer that takes up little to no space and works like belongs in the 1980's.
With this version complete, it was time to start on my own full DIY build. This time around, I decided to make it look like it fell right out of the 1980's and somewhat similar to Geoff Graham's Maximite. Functionally, it's identical to the version above, but made to fit my vision and using all readily available solderable PCBs to give it that awesome homebrew PC look. But, I'll cover all of that in the next post!
Until next time, thanks for reading!