Learning The Ropes With A Raspberry Pi Mandelbrot Cluster

You’ve probably heard it said that clustering a bunch of Raspberry Pis up to make a “supercomputer” doesn’t make much sense, as even a middle-of-the-road desktop could blow it away in terms of performance. While that may be true, the reason most people make Pi clusters isn’t for raw power, it’s so they can build experience with parallel computing without breaking the bank.

So while there was probably a “better” way to produce the Mandelbrot video seen below, creator [Michael Kohn] still learned a lot about putting together a robust parallel processing environment using industry standard tools like Kubernetes and Docker. Luckily for us, he was kind enough to document the whole process for anyone else who might be interested in following in his footsteps. Whatever your parallel task is, and whatever platform it happens to be running on, some of the notes here are likely to help you get it going.

It’s not the biggest Raspberry Pi cluster we’ve ever seen, but the four Pi 4s and the RGB LED festooned enclosure they live in make for an affordable and space-saving cluster to hone your skills on. Whether you’re practicing for the future of software development and deployment, or just looking for something new to play around with, building one of these small-scale clusters is a great way to get in on the action.

Continue reading “Learning The Ropes With A Raspberry Pi Mandelbrot Cluster”

Zooming Through The Mandelbrot Set On An Atari

The Mandelbrot set, according to Wikipedia, is “the set of complex numbers c for which the function f_{c}(z)=z^{2}+c does not diverge.” Even if you don’t understand the mathematics behind it, you’ve likely seen the complicated fractal images generated by zooming in on the border of the Mandelbrot set. [Scott Williamson] not only got this set rendering on an Atari, but managed to create animated videos of the results. 

Emulators were key to the project’s success.

Doing the work was no mean feat. While it takes just 10 lines of Atari BASIC to render the set on an Atari 800, getting the animations made and into a modern video format took much effort. [Scott] used the Atari800Win-PLus emulator to zoom in on a variety of locations on the fractal curve and recorded the results over a weekend.

However, compositing the various frames into smooth-scrolling videos took more effort, with a Python script and ffmpeg required to stitch everything together into the results you see on YouTube. The final videos were combined with Atari chiptune music from [Adam Sporka] to help round out the presentation.

The result is reminiscent of an old-school demo, even if everything here was assembled slowly on modern computers from the raw Atari output. We’ve seen other great Mandelbrot feats before, too, like this real-time explorer built on an FPGA. Video after the break.

Continue reading “Zooming Through The Mandelbrot Set On An Atari”

Hackaday Links Column Banner

Hackaday Links: February 28, 2021

In an announcement that came as a surprise to few, NASA now says that landing humans on the Moon by 2024 is no longer likely. Acting administrator Steve Jurczyk lays the blame at the feet of Congress, for failing to provide the funds needed for Human Landing Systems development, a critical step needed to meet the aggressive overall timeline. The announcement doesn’t mark the end of the Artemis program; in fact, NASA is continuing to work on a realistic timeline for getting boots back on the lunar surface, and a decision on which of the three submitted proposals for a lunar lander will be further developed should be coming in the next few months. As far as we can see, this is simply an adjustment to the original timeline for a landing, but given the stunning recent success of Perseverance showing just what robots can do, we’d expect pushback from some quarters on the need for human exploration.

The entry-level 3D design market was thrown into considerable turmoil last year when Autodesk changed the licensing terms for its flagship Fusion 360 package. Hobbyists who had been enjoying relatively unfettered access to the powerful suite chafed at the new restrictions, leaving many to threaten to jump ship, apparently without much thought given to the dearth of alternative products. That may be changing now that Dassault Systèmes has announced two new versions of SolidWorks aimed at the maker and student segments. The Makers offer is intended for hobbyists who want to design for benchtop manufacturing methods like 3D-printing. The Students offer is aimed at engineering and design students looking to gain experience with the tools they’ll be expected to have mastered by the time they enter the job market. It looks like the Makers offer will be at least partly contingent on the interest expressed by the community, so you might want to make your feeling know on the subject. If the Makers edition comes to pass in the second half of this year, it will likely target a $99/year price point.

We stumbled upon an interesting YouTube series the other day that stirred the creative juices. We all probably remember the first time we learned about the Mandelbrot set, the fractal number set that looks something like a lumpy kidney bean and continues to do so no matter how far you zoom into it. The image may be complex but the math behind it is simple enough to implement in software that it’s often done as an exercise for CS students and other unfortunates. But implementing a Mandelbrot set generator in logic is possible too, which WildEngineering did in this video series. Rather than implement this as discrete logic gates, he used a neat logic simulator called Digital, which looks like a handy tool to learn all by itself. The Mandelbrot generator concepts are really instructive too, and it sure seems like the next logical step would be to gather the needed 74xx-series chips and start breadboarding. We’d love to give it a whirl ourselves, but won’t be heartbroken if someone beats us to it.

If it sometimes appears that we at Hackaday get a little frustrated with the comments section of the articles we write, rest assured that we know that we have the best readers on the planet, hands down. Where the toxicity of other corners of the Internet is often unbearable, our readers truly do make this a fabulously collaborative environment, on the whole.

In fact, some commenters even go so far as to basically write their own articles in response to one of ours, and when that happens we like to point it out. The article that spawned the effort was Kristina Panos’ excellent “What If I Never Make Version Two?”, a recent piece that dips a toe into the psychology of hacking. Peter Walsh picks up on the theme with his Hackaday.io page entitled “The Psychology of Version Two”, which we really enjoyed. After a brief look at the neurochemistry of happiness, Peter dives into some “brain hacks” to assess the need for a version 2. There are some great tips, and we really enjoyed both the original article and Peter’s response.

STM32 Gets Up Close And Personal With Mandelbrot

The Mandelbrot set is a curious mathematical oddity that, while interesting in its own right, is also a useful tool for benchmarking various types of computers. Its constant computing requirement when zooming in and out on the function, combined with the fact that it can be zoomed indefinitely, means that it takes some quality hardware and software to display it properly. [Thanassis] has made this a pet project of his, running Mandelbrot set visualizations in different ways on many different hardware platforms.

This particular one is based on an STM32 board called the Blue Pill, which [Thanassis] chose because he hadn’t yet done a continuous Mandelbrot zoom on a microcontroller yet. The display is handled by a tiny 16K IPS color screen, and some clever memory tricks had to come into play in order to get smooth video output since the STM has only 20 kB available. The integer multiplication is also tricky on a platform this small while keeping the continuous zoom function, so it’s limited to fixed point multiplication.

Even with the limitations of the platform, he is still able to achieve nearly double-digit FPS rates with this one. If you want to play around with graphics like this on an STM platform, [Thanassis] has released all of the source code on his GitHub page, but if you’d like to see more Mandelbrot manipulation you can check out one of his older projects where he built a similar project on an FPGA.

Continue reading “STM32 Gets Up Close And Personal With Mandelbrot”

FPGA Used VHDL For Fractals

Over on GitHub, [ttsiodras] wanted to learn VHDL. So he started with an algorithm to do Mandelbrot sets and moved it to an FPGA. Because of the speed, he was able to accomplish real-time zooming. You can see a video of the results, below.

The FPGA board is a ZestSC1 that has a relatively old Xilinx Spartan 3 chip onboard. Still, it is plenty powerful enough for a task like this.

Continue reading “FPGA Used VHDL For Fractals”

Interactive Mandelbrot Set Viewer Runs On FPGAs

The Mandelbrot Set is a mathematical oddity where a simple function creates an infinitely complex landscape that you can literally zoom into forever. Like most people, I’ve downloaded Mandelbrot set viewers and marveled at the infinite whorls and spirals, and then waited while each frame took minutes or hours to render as I zoomed in. [Michael Henning], [Max Rademacher] and [Jonathan Plattner] decided to throw some modern computational muscle at this problem by building an interactive Mandelbrot set viewer using a laptop and two FPGA boards.

Continue reading “Interactive Mandelbrot Set Viewer Runs On FPGAs”

Generating The Mandelbrot Set With IBM Mainframes

[Ken Shirriff] is apparently very cool, and when he found out the Computer History Museum had a working IBM 1401 mainframe, he decided to write a program. Not just any program, mind you; one that would generate a Mandelbrot fractal on a line printer.

The IBM 1401 is an odd beast. Even though it’s a fully transistorized computer, these transistors are germanium. These transistors are stuffed onto tiny cards with resistors, caps, and diodes, than then stuck in a pull-out card cage that, in IBM parlance, is called a ‘gate’. The computer used decimal arithmetic, and things like ‘bytes’ wouldn’t be standard for 20 years after this computer was designed – 4,000 characters of memory are stored in a 6-bit binary coded decimal format.

To the modern eye, the 1401 appears to be a very odd machine, but thanks to the ROPE compiler, [Ken] was able to develop his code and run it before committing it to punched cards. An IBM 029 keypunch was used to send the code from a PC to cards with the help of some USB-controlled relays.

With the deck of cards properly sorted, the 1401 was powered up, the cards loaded, and the impressive ‘Load’ button pressed. After 12 minutes of a line printer hammering out characters one at a time, a Mandelbrot fractal appears from a line printer. Interestingly, the first image of the Mandelbrot set was printed off a line printer in 1978. The IBM 1401 was introduced nearly 20 years before that.