1. 30

The Raspberry Pi in its myriad variants and descendants has sparked a true revolution in the electronic and computer hobbyist worlds, and deservedly so.

But for those of us who love even older and smaller things, what else is out there? In this thread, show off the 6502 and Z80 and M68k hobbyist boards that you’ve seen!

  1.  

  2. 24

    I just wanted to highlight a distinction for anyone new to the scene who stumbles upon this thread. I think people lump a lot of hobbyist boards together. The RPI is a linux box basically. It has some headers on it for gpio but it runs ssh and uname works. This is kind of a “huge version” of embedded.

    In this category you have things like Beagleboard, Odroid, the Asus Tinkerboard, RockPI, Teensy, etc

    Then are the arduino style boards like @codejake said, the ESP32 compatible stuff, Particle.io, Sparkfun’s Thing. Many others. Even in the arduino proper space you have dev boards and then “pro” boards. Pro boards have less headers and tools on them because they are supposed to ship. After getting your code/hardware developed, you’d probably build a custom chip with a reduced BoM to do mass manufacturing. This is leaving my experience boundary, I’m just a hobbyist.

    I just wanted to compare these two categories because if you are looking for the next step from the RPi, look at embedded devices where you burn your code in, can’t SSH or have an option to CAD up a design using Fritzing. It’s very different and you’ll learn a lot.

    1. 2

      Teensy boards are in the Arduino-esque camp — they have ARM Cortex-M CPUs and at most a few hundred KB of RAM. Definitely not capable of running Linux!

      1. 2

        So you actually can build Linux without MMU support. It’s an unusual choice, but it’s not actually impossible to run Linux on (especially beefier) microcontrollers.

        1. 2

          You can build it but it’s not what any normal person would regard as Linux. You’re not going to ssh into it, edit some code in vi, compile with gcc, run it.

        2. 1

          Ah, yeah. I edited my post incorrectly. Thanks. :)

          1. 1

            You’re right but the latest Teensy 4.1 is almost in the “huge” category: 600MHz and 1MB RAM. Bigger than some historical machines.

          2. 2

            You hit the nail on the head but I also find this distinction a little funny. If you break it down a RasPi with its GPIO pins are also just a much nicer version of soldering your own (parallel port) cable and plugging it in, maybe a case of “just a little more usability makes for really nice non-enthusiast product”, because I completely file myself under that category. Before the RasPi I had the knowledge, the hardware and the will to tinker, but it was just too tedious to do it more than once or twice.

          3. 19

            I enjoy the ESP32 boards quite a bit. They are very cheap, they come with WiFi and BT built in, and you can write either C or Arduino code for them.

            There are the older esp8266 boards but they lack some cool power management stuff the newer ESP32 boards have.

            1. 3

              They also come with a pretty nice SDK - it’s usually the bane of the smaller boards, that the SDKs are terrible or you end up having to write a whole lotta a drivers yourself, which isn’t what I find fun ;-)

              1. 1

                I agree, the ESP32-IDF SDK is surprisingly pleasant. But there are some other embedded SDKs that seem nice too, like Zephyr and mbedOS, that support a lot of popular ARM-based boards. (Though I haven’t actually used them.)

              2. 3

                I have a bunch of the ESP8266s flashed with Tasmota, on breadboards with a Dallas temperature sensor for monitoring stuff around the house.

                One of them has a relay which controls my garage door in parallel with the garage door switch at the wall. I have a few that are embedded in “smart outlets” bought from Amazon that I flashed Tasmota over-the-air as to avoid closed source firmware.

                All of these are connected to my Hubitat for automation and pushing temps to InfluxDB. Here is a snapshot of one of my Grafana dashboards: https://snapshot.raintank.io/dashboard/snapshot/jzZznlmjEWaatSNw1AbN2znAPcC4N8wE

                1. 2

                  Hubitat rules so hard.

                  1. 1

                    I bought the C5 shortly after it was released and they have done a great job improving it over time, the web UI is lot more responsive than it used to be and there has been a steady flow of sane features while still keeping it rather simple/focused. I like it a lot!

                    1. 2

                      My only real issue is that geofencing with the mobile app doesn’t work consistently. Everything else is extremely reliable.

                      1. 2

                        Agreed, forgot about geofencing… My current workaround is the OwnTracks phone app with OwnTracks Presence app for Hubitat: https://github.com/bdwilson/hubitat/tree/master/OwnTracks-Presence - the downside is battery consumption on my phone is higher. I also use an app for presence based on WiFi since my phone has a static IP on my LAN.

                2. 2

                  For the embedded category I really like the Nordic nRF52 chips. Well supported in Rust, nice bunch of peripherals onboard, debugging with OpenOCD+gdb works well, official docs are nice. Supports BLE, 802.15.4, ESB for radio. No Wi-Fi but that only makes everything lighter.

                  1. 1

                    That’s what I’ve started with, and they are fun for sure. I went with the Adafruit Huzzah32 boards, for a nice combination of features and low-enough price. (Might use something else if making a bunch of something.)

                    Next up, using uLisp on the one I’ve got on order.

                    1. 1

                      Alternative: WFI32

                    2. 5

                      I bought a Precursor; my hope is to get something like Palm OS (or maybe even Palm OS in emulation/68k softcore, who knows) on it.

                      1. 3

                        The ESPRESSObin: https://espressobin.net/

                        We used this board at work to evaluate the platform, we then built our own hardware based on this SoC. Linux worked out of the box like a charm. Was a real pleasure to develop for this.

                        1. 3

                          I quite like using Adafruit’s line of Feather dev boards: https://www.adafruit.com/feather Sparkfun has also recently released a format called MicroMods, which use the M.2 connector as the common interface: https://www.sparkfun.com/micromod

                          And for SBCs, I’m partial to either the Odroid XU4, or NanoPi’s relatively unknown NanoPi Neo boards.

                          1. 3

                            If you’re fine with making your own, then you might find Retrobrew Computers interesting.

                            1. 3

                              there’s a decent list + a comparator on https://hackerboards.com/

                              1. 2

                                Lots of boards, but parametric search sorely lacking.

                              2. 2

                                Are there still 6502 / Z80 / 68K chips being made? I haven’t heard of any modern-day hardware based on them.

                                I do know the venerable 8051 is still popular for very-low-end embedded use cases, but even back in the day it was described as extremely awkward to program, so I’d be surprised if hobbyists used it! (But what do I know, I found the 6502 nearly impossible back in my teens, so I never got into assembly on my Apple II. My friend’s Z80-based system was easier, I thought.)

                                1. 3

                                  Yes. 6502 chips are still being made/sold by Western Design Center (https://www.westerndesigncenter.com/). Z80s are still around in the Zilog Z80, Z180 and eZ80 line. Freescale (descendant of Motorola) produces variants of the 68000/68020 as embedded products (or did until recently). There were also dozens second source and derivatives of these processors, and someone might still be selling those; I haven’t checked in a while.

                                  There are also specialty shops like Innovasic that recreate/reverse engineer old processors like this in FPGA/ASICs for long term support purposes. They aren’t cheap.

                                  I still use 8051s for hobby stuff. They’re weird but there’s, what, 50 years of tooling and experience to work with.

                                  1. 4

                                    Freescale (descendant of Motorola)

                                    Who are now part of NXP :)

                                    1. 1

                                      My dad, who worked for Zilog in their heyday circa 1980, would be happy to hear that.

                                      (He later worked for Xilinx, so he’d be happy about all the hobbyists using FPGAs too!)

                                    2. 1

                                      z80 variant is still being made iirc as is the 6502 (and 65816). There are of course plenty of FPGA implementations.

                                      1. 1

                                        You can buy 17 MHz (?) 65C02 chips for $8, brand new. They’re still being made. There’s a very interesting new board being made using them running at 8 MHz: https://www.commanderx16.com/

                                        8051 is not bad if most of your variables fit into 8 registers and everything fits into 256 bytes. Talking to more memory than that is pretty annoying

                                        z80 and 6502 each have their own annoying quirks. With cunning you can hand-write some pretty tight stuff on either (in completely different ways) but both are awful for compiling C (or Pascal back then) to.

                                      2. 2

                                        I would argue that it would be worth to take a look at https://radiona.org/ulx3s - an affordable FPGA board equipped with a lots of extra components and expansions. And open hardware, which gives extra credits.

                                        1. 2

                                          Some links:

                                          1. 2

                                            I built a DIY mobile phone using a Teensy and it was a delight to work with. Makes me want to build something else. https://www.pjrc.com/teensy/

                                            1. 2

                                              I am surprised that micro:bit has not been mentioned. Checkout this glove.

                                              1. 2

                                                If you’re interested in a survey of ultra-low-cost parts that mostly have dev boards available, Jay Carlson did a fantastic job of compiling all that: https://jaycarlson.net/microcontrollers/

                                                1. 2

                                                  Blue Pill and other STM32 Cortex-M dev boards are very nice for small projects without an OS (or even FreeRTOS). You can write Rust, too, which makes them more comfortable than ESP32. And they’re much much more powerful than AVR boards (eg. Arduino).

                                                  Of course with any microcontrollers you have to be prepared to read datasheets (and errata!) and debug a lot before you can even get an LED to blink. Full-fledged computers such as the Raspberry Pi tend to be much easier to work with.

                                                  1. 1

                                                    My experience with ESP32 was a lot better than that! Once I got the toolchain (GCC) and SDK installed, the example programs Just Worked. When working on my own code, it really helped that I could magically use GDB to debug, thanks to a little debug-server that can link into the program and take over on an exception.

                                                    1. 1

                                                      Yeah, you also get openocd+gdb debugging with Rust or C on STM32. With ST-Link the workflow is really nice. It’s not that compilation or debugging is difficult. It’s that doing anything specific with the hardware from scratch is difficult.

                                                      Say, you’re trying to run PWM on pin 17 with a 20ms pulse every 400 milliseconds. That’s going to be very difficult unless you know what timers the device has, how their registers exactly affect the timer and how the PWM functionality uses said timer.

                                                      Of course it’s a different matter if you have just the right sample code. But that’s not what’s interesting about embedded for many people. And I’m quite confident that blinking an LED is an achievement on ESP32 too if you do it based on just the datasheets.

                                                  2. 1

                                                    M5Stack is a small computer loaded with features. Haven’t used one, but the specs look interesting.

                                                    1. 1

                                                      I’ve got a Digilent Nexys board, which has a Xilinx FPGA - I’ve had some lovely times playing around with “pure” FPGA but also played around with MicroBlaze, which is a soft-kernel with the goal of running linux on it.

                                                      I also got a few MikroE boards - a PIC v7 and a AVR v7 - for when you need to play around with the smaller 8 or 16 bitters.

                                                      On top of that I have a stack of TI boards

                                                      • LAUNCHPAD for MSP430s, and a bunch of different MSP430s
                                                      • LAUNCHPADXL for the C2000 (not a fan of those, but that’s a different story)
                                                      • Bluetooth development boards for Stellaris

                                                      In the same drawer, there’s also an old KEIL development board with a ARM 7 processor, and a few mbed boards too, also ARM.

                                                      I should probably get around to throw/give away the boards I don’t use anymore.

                                                      1. 1

                                                        Give https://linuxgizmos.com/ a browse. There’s hundreds

                                                        1. 1

                                                          I’m not really a serious electronics hobbyist, but I know a lot of them, and the most popular board for basic hacker projects is the Adafruit Feather. It has a lot of IOs, it doesn’t need Linux (and all the pains of running Linux), and it’s really fast (enough to drive displays and speakers directly). The Raspberry Pi Pico is sort of similar but it has a lot fewer IOs. As you start building bigger projects, IOs become the limiting factor, and you have to start using multiple MCUs and connecting them, which gets more and more complicated….

                                                          Another one I want to see succeed is WebFPGA. It turns out the software used to program FPGAs is notoriously clunky and huge (intended for professionals), so WebFPGA is a cheap custom FPGA board + a web interface that lets you just edit VHDL in the browser and see the results immediately.