If you’ve ever wanted to get started in retrocomputing, or maybe the Commodore 64 you’ve been using since the 80s just gave up the ghost, [Rick] aka [Mindrobots] has just the thing for you: a retrocomputer based on a PIC microcontroller and a Parallax Propeller.
The two chips at the heart of the computer are both open source. The Propeller is the perfect board to take care of the I/O, video, and audio outputs because it was purpose-built to be a multitasking machine. The microcontroller is either a PIC32MX150 or a PIC32MX170 and is loaded with a BASIC interpreter, 19 I/O pins, a full-screen editor, and a number of communications protocols. In short, everything you would ever want out of a retro-style minicomputer.
The whole computer can be assembled on a PCB with all the outputs you can imagine (VGA, PS/2, etc) and, once complete, can be programmed to run any program imaginable including games. And, of course, it can act as a link to any physical devices with all of its I/O because its heart is a microcontroller.
Retrocomputing is quite an active arena for hackers, with some being made from FPGAs and other barebones computers being made on only three chips. It’s good to see another great computer in the lineup, especially one that uses open chips like the Propeller and the PIC.
In what way is the PIC open source?
The Micromite software written for the PIC is open source. Sorry if there was confusion there.
Please consider rewriting. Fluff lines to fill space are less important than accurately reported content.
Now for something positive: I love seeing stuff like this on HAD. Lots of people making their own retrocomps these days.
We already adjusted the text of the Instructable. That’s the part we have control of.
Did you read ?
I strongly believe, marrying a Propeller with a chip containing MMBASIC is a bad idea… from the licensce point ov view…
Formatting ate http://mmbasic.com/source.html in previous reply.
This is also not a minicomputer.This http://archive.computerhistory.org/resources/text/DEC/Digital.PDP-11.1970.102646128.fc.lg.jpg is a minicomputer. Minicomputers are actually pretty large systems physical by todays standards.
As far as I know (and as far as google tells me in a quick search), the PIC32 is NOT open source! That is, Microchip did not release the hardware design (HDL files) of this controller, and I’d be very surprised if they would ever do so, never mind while the chip is actually in production.
The fact that they loaded open-source FIRMWARE does not make it an open-source CHIP.
Yeah. Post writing is very misleading. Atmel chips are not open sourced as far as I know either. I dont think Bunnie’s laptop would even fit the bill here. We are talking open sourced firmware here, as in “the person released the code as well as hardware design files.” But honestly if they hadn’t, HAD shouldn’t be rewarding with a post. I assume if its on HAD it is open sourced hardware/firmware unless you say otherwise.
Sorry I don’t normally bag on the post writing styles but its not only a rookie mistake, but a super obvious one for anyone with even just a partial clue.
Cool little board
Now if I could get my hands on some DID chips…
SID not DID.
I remember seeing SID emulation code for the propeller on HAD once.
Yep http://obex.parallax.com/object/532
If there is a free core and memory on the Micromite, SIDcog should just drop into the code. Should just have to update the serial interface code and point SIDcog at the audio output pins.
We’ve been on a “code freeze” for the last week or so to make sure we have as many bugs or potential issues out of the code. This weekend I intend to upgrade MODE 2 (Retrotext mode) to include the SIDCOG object. We should be able to program the SID from MMBASIC almost “exactly” as we did on the C64. It’ll only take a special MMBASIC subroutine to the I2C call on the Propeller to get it done.
SwinSID has a long history. Has been tested in a C64 with only a few things not ready yet.
http://www.swinkels.tvtom.pl/swinsid/
Google paperclip computer. I want to see an emulation or simulation of that, with optional automation links so each step doesn’t need to be manually actuated.
The coolest part of the thing is the hand made BCD rotary switches.
That’s cool. What I’m more interested is using the Prop as a set of virtual peripherals and hooking it up to the bus of an honest to goodness Z80, 1802, 6800/09 or 6502. That’s some real retrocomputing in my book.
I’m not a fan of the Propeller, but I AM a fan of whoever succeeds in creating (or re-creating) a decent single-tasking computer. Well done.
Back in the 1980s, people could hack the hell out of their computers, because the hardware interfaces were simple and programming was straightforward. Then two trends took our computers away from us: first protected-mode multi-tasking processors like the 80386 and the 68K series and operating systems like MacOS and Windows, which made “peeks” and “pokes” unavailable to us by making all I/O devices kernel-owned resources, then USB, which was a hardware interface deliberately and specifically designed to be inaccessible to hobbyists and which displaced the simpler interfaces on nearly all computers. It’s only in recent years that we’ve been given access to the USB port (through the long, hard work of a number of pioneering hackers), and the advancement of microcontrollers has made these as powerful as the 1980s microprocessors while still giving us full access to the chips we buy.
Look at how so many Raspberry Pi projects work: they use the ARM (protected mode multi-tasking) processor for heavy processing, but almost every project I see that includes custom hardware controlled by the computer uses a Microchip or Atmel microcontroller to actually interface to the outside world.
A Commodore 64 with an SD card slot? THAT’s progress, and I’m not joking when I say that.
One gripe, though, at HaD, not the creators of this project: the link only takes you to an instructables.com page that doesn’t give a lot of information. To learn more about this project, go to propellerpowered.com.
> first protected-mode multi-tasking processors like the 80386…
I quite like memory protection. I’m glad we have stuff like non-executable stacks too.
>and the 68K series and operating systems like MacOS and Windows,
68K versions of MacOS didn’t have any memory protection and stuff crashed all the time. All modern operating systems have it because it’s what we call “a good idea”.
>which made “peeks” and “pokes” unavailable to us by making all I/O
>devices kernel-owned resources,
OSes give you interfaces to do stuff like that in a safe way i.e. not shit all over the OS and other processes. In Linux you have a device called /dev/mem where (depending on kernel options) you can shit all over your memory to your heart’s content as long are the process is running as root. If the OS interface is too slow you’ll have to write something that runs at the same level as the kernel. For Linux you would write your own module.
>Look at how so many Raspberry Pi projects work: they use the
>ARM (protected mode multi-tasking) processor for heavy processing,
If you think that developing any sort of complex software in an environment that doesn’t have memory protection when you have one that does available is sane or a good idea you need to close the editor right now.
>Microchip or Atmel microcontroller to actually interface to the outside world.
The reasons for that aren’t anything to do with the Pi having a multitasking OS with memory protection.
I do love how people get all teary eyed over old computers and how much better they were be conveniently seem to forget all of the issues.
>68K versions of MacOS didn’t have any memory protection and stuff crashed all the time. All modern operating systems have it because it’s what we call “a good idea”.
Memory protection does not keep bad programs from crashing. At best, all it can do is keep bad programs from crashing other programs running on the same machine. I have a better solution: don’t tolerate bad programs. Macs didn’t stop crashing when they went to 68020; they just crashed differently.
My ARM-based phone has memory protection, and quite often I have to reboot it when an application screws up and locks up everything. Tell me again what the benefit of having the memory protection was.
>The reasons for that aren’t anything to do with the Pi having a multitasking OS with memory protection.
I’m sure there are cases where this is true, such as timing-critical tasks. However, I am just as sure that in MANY cases it’s simply easier to do the low-level interface on a microcontroller than to deal with kernel modules in order to access your hardware.
> which made “peeks” and “pokes” unavailable to us by making all I/O devices kernel-owned resources,
So ? Just write a kernel module.
You say that, I’m guessing, from the Linux perspective. How much did it cost to get the tools required to write device drivers for Windows and MacOS in the 1990s?
BrightBlueJim,
If you took a popular 1980’s microcontroller, added processing power in a way that doesn’t require a protected-mode multitasking, put in some shared memory that you could peek and poke all you want, and threw on a boot loader that works over an RS-232 port, you’d essentially have a Propeller microcontroller. I am curious as to why you are not a fan of it.
Maybe the Propeller microcontroller is not what you think it is.
— David Carrier
Parallax Inc.
I want to say “burned” but “sun-beamed” would seem more applicable. I did wish I could wrap my head around how you guys was able to create a single-core multitasking chip with a reasonable clock speed.
I have to admit that my prejudice is based on my first impression of the Propeller, which was, “not useful for any project I have in mind”. I could easily be wrong about this and I’ll look again. The impression I got when the Propeller was released was that it was a bunch of processors, each having to wait its turn in order to do any RAM access operation. Like I said, I’ll take another look. Maybe it’s more sensible to think of it more like a single processor running multiple independent threads. I kind of LIKE the idea of being able to do multiple tight service loops without having to use interrupts. And it was kind of cheap of me to say “not a fan” without backing that up. Thank you for pointing out my prejudice.
BrightBlueJim,
In mass-produced devices, the Propeller microcontroller is most cost effective in tasks that require determinism, low I/O latency, or high data throughput. (It allows a microcontroller to do what would often take multiple microcontrollers or a microcontroller and a CPLD or FPGA)
If you aren’t mass producing something, the cost of the microcontroller isn’t usually what is critical, but instead the difficulty and time it takes to write the program it is running. In the case of the Propeller microcontroller, each interrupt routine essentially runs in its own core, so it makes timing much easier.
The shared RAM access is interleaved, as you mentioned, but each core gets access once every four instruction periods, far more often then most code accesses the RAM, so it minimally effects software running on the core. (It is far easier than checking out memory, using it, then checking it back in.) There are also 496 32-bit words local to each core, for instructions and data, which do not need to wait for shared RAM access.
Also, not being a fan doesn’t mean you don’t like it, it just means you haven’t tried it out, so you don’t have a positive opinion of it…yet.
— David Carrier
Parallax Inc.