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.

Exploring The Mandelbrot Set In Real Time

The Mandelbrot set – the fractal ‘snowman turned on its side’ seen above – has graced the covers of magazines, journals, and has even been exhibited in art galleries. An impressive feat for what is nothing more than a mathematical function, and has become something of an obsession for [Chiaki Nakajima].

Even on modern computers, generating an image of a portion of the Mandelbrot set takes a good bit of time. When [Chiaki] discovered this fractal in the mid-1980s, the computers of the day took hours to generate a single, low-resolution image. Real-time zooming and scrolling was impossible but [Chiaki] made the best of what he had on hand and built Pyxis, a Mandelbrot set generator made entirely out of TTL logic chips (Google Translate here).

The original Pyxis connected to a desktop computer via a breakout box. while a special program toggled the bits and registers inside the Pyxis to generate pictures of the Mandelbrot set a thousand times faster than the CPUs of the day could muster.

Time marches on, and the original logic chip Pyxis is can be easily surpassed by even the slowest netbooks. There is, however, another way to build a hardware Mandelbrot set generator: FPGAs.

A few years ago, [Chiaki] began work on the Pyxis2010 (translation), an FPGA-based Mandelbrot set generator able to dynamically zoom and pan around the world’s most popular fractal. Built around an Altera Cyclone III FPGA he picked up from Digikey for $600 (no, not a dev board, just a bare chip), [Chiaki] began deadbugging his circuit directly onto the pins of the hugely expensive FPGA. A man with a steady hand and no fear if there ever was one.

Instead of connecting his Mandelbrot generator to a computer and using it as a co-processor, [Chiaki] decided he wanted something more portable. He found an old Sony PSP, removed the LCD screen, and integrated it into his circuit. After a careful bit of dremeling and fabrication, [Chiaki] had a hand-held Mandelbrot generator that is able to display images of the world’s most famous fractal faster than any desktop computer.

It goes without saying this build is incredible. The technical skill to build an insanely fast Mandelbrot generator on an FPGA is astonishing, but basing it off a logic-chip based build reaches into the realm of godliness. You can check out a video of this amazing build after the break.

Props to [Ian Finder] for sending this one in.

Continue reading “Exploring The Mandelbrot Set In Real Time”

Fractal Viewer Can Zoom And Enhance Like On CSI

This fractal viewer is a great way to get your feet wet with Field-Programmable Gate Arrays. The project will give you some experience working with video output, user input, and a whole bunch of math and memory management. [Hamster] built it using the Papilio Plus board which hosts a Spartan 6 FPGA. This continues his odyssey into the realm of hardware design; part of which we looked at back in December.

The arcade Megawing for the dev board gives him easy access to the controls needed to scroll and zoom on the fractal design. Calculations to generate the shape are being run at 240 MHz, with the VGA output running at 80 MHz. The device has enough horse power and SRAM to show an 800×600 pixel output with a 60 Hz refresh rate.

We really liked the logic diagram that [Hamster] drew up when planning how the calculations would be handled. It’s not overly complex, but it took us a while to conceptualize how everything fits together. It’s certainly an improvement from his last attempt as we couldn’t make heads or tails out of that flow chart.

If you’re just interested in the pretty shapes and colors there’s a demo embedded after the break.

Continue reading “Fractal Viewer Can Zoom And Enhance Like On CSI”