Build Your Own Supercomputer with ESP32s

If the computer you have isn’t particularly fast, there’s a well-documented way to get more out of it. You just need more of the same computer, and you can run your tasks on them all at the same time. Building computer clusters is an effective way of decreasing the time it takes for computers to solve certain problems, even if the computers themselves aren’t top-of-the-line hardware. Of course, with cheap enough hardware, people will build clusters out of just about anything, including the ESP32.

For this project, [Wei Lin] admits that this isn’t really a serious attempt at building speedy hardware, but rather an interesting exercise in creating a cluster as a sort of learning experience. ESP32 boards can be found for around $10 so building an experimental cluster with these is even more feasible than using the Raspberry Pi. [Wei Lin] goes into a great amount of detail on his GitHub page about all of his goals with the project, most of which involve exploring the functionality of the new cluster and its underpinnings.

While this might seem like little more than a thought experiment, it does have the advantage of being a great solution for problems that involve gathering data from points that are physically very far from one another. If you’ve ever been interested in parallel computing or computing clusters, this is a great project to check out. If you have more Raspberry Pis on hand than ESP32s and still want to build a cluster, check out this project that used a mere 750 of them for one.

 

Moltoduino: Arduinos All the Way Down

It is getting difficult to find a desktop or laptop computer with only a single CPU. Even a typical ARM-based computer now probably has multiple cores. Of course, there’s nothing to stop you from using multiple microcontrollers — like the Arduino — together. To make the process neater, [Dimitris Platis] put together Moltoduino, essentially an Arduino on a shield made to plug into another Arduino. And, yes, they will stack. You can see a video about the open source boards, below.

The key is how the board brings the pins out to connections that are easy to jumper between boards. There are several obvious use cases, but one that [Dimitris] is particularly interested in is hardware-in-the-loop testing. The idea is that you can use a simulated I/O device in one computer to exchange fake data with the software under test.

Continue reading “Moltoduino: Arduinos All the Way Down”

Firing up 750 Raspberry Pis

Creating Raspberry Pi clusters is a popular hacker activity. Bitscope has been commercializing these clusters for a bit now and last year they created a cluster of 750 Pis for Los Alamos National Labs. You might wonder what an institution know for supercomputers wants with a cluster of Raspberry Pis. Turns out it is tough to justify taking a real high-speed cluster down just to test software. Now developers can run small test programs with a large number of CPU cores without requiring time on the big iron.

On the face of it, this doesn’t sound too hard, but hooking up 750 of anything is going to have its challenges. You have to provide power and carry away heat. They all have to communicate, and you aren’t going to want to house the thing in a few hundred square feet which makes heat and power even more difficult.

Continue reading “Firing up 750 Raspberry Pis”

Imagine A Cluster Of ESP32s

When the ESP32 microcontroller first appeared on the market it’s a fair certainty that somewhere in a long-forgotten corner of the Internet a person said: “Imagine a Beowulf cluster of those things!”.

Someone had to do it, and it seems that the someone in question was [Kodera2t], who has made a mini-cluster of 4 ESP32 modules on a custom PCB. They might not be the boxed computers that would come to mind from a traditional cluster, but an ESP32 module is a little standalone computer with processing power that wouldn’t have looked too bad on your desktop only in the last decade. The WiFi on an ESP32 would impose an unacceptable overhead for communication between processors, and ESP32s are not blessed with wired Ethernet, so instead the board has a parallel bus formed by linking together a group of GPIO lines. There is also a shared SPI SRAM chip with a bus switchable between the four units by one of the ESp32s acting as the controller.

You might ask what the point is of such an exercise, and indeed as it is made clear, there is no point beyond interest and edification. It’s unclear what software will run upon this mini-cluster as it has so far only just reached the point of a first hardware implementation, but since ESP32 clusters aren’t exactly mainstream it will have to be something written especially for the platform.

This cluster may be somewhat unusual, but in the past we’ve brought you more conventional Beowulf clusters such as this one using the ever-popular Raspberry Pi.

Terrible Cluster of PIs

When we first saw [Ajlitt’s] Hackaday.io project Terrible Cluster we thought, perhaps, he meant terrible in the sense of the third definition:

3. exciting terror, awe, or great fear; dreadful; awful. (Dictionary.com)

After looking at the subtitle, though, we realized he just meant terrible. The subtitle, by the way, is: 5 Raspberry PI Zeros. One custom USB hub. Endless disappointment.

There are four Raspberry Pi Zero boards that actually compute and one Raspberry Pi Zero W serves as a head node and network router. The total cost is about $100 and half of that is in SD cards. There’s a custom USB backplane and even a 3D-printed case.

At first, using five tiny computers in a cluster might not seem like a big deal. Benchmarking shows the cluster (with a little coaxing) could reach 1.281 GFLOPS, with an average draw of 4.962W. That isn’t going to win any world records. However, the educational possibilities of building a $100 cluster that fits in the palm of your hand is interesting. Besides, it is simply a cute build.

We’ve seen much larger Pi clusters, of course. You might be better off with some desktop CPUs, but — honestly — not much better.

Using the GPU from JavaScript

Everyone knows that writing programs that exploit the GPU (Graphics Processing Unit) in your computer’s video card requires special arcane tools, right? Well, thanks to [Matthew Saw], [Fazil Sapuan], and [Cheah Eugene], perhaps not. At a hackathon, they turned out a Javascript library that allows you to create “kernel” functions to execute on the GPU of the target system. There’s a demo available with a benchmark which on our machine sped up a 512×512 calculation by well over five times. You can download the library from the same page. There’s also a GitHub page.

The documentation is a bit sparse but readable. You simply define the function you want to execute and the dimensions of the problem. You can specify one, two, or three dimensions, as suits your problem space. When you execute the associated function it will try to run the kernels on your GPU in parallel. If it can’t, it will still get the right answer, just slowly.

Continue reading “Using the GPU from JavaScript”

Industrial Indicator Makes the Move from PLC to FPGA

Industrial controls are fun to use in a build because they’re just so — well, industrial. They’re chunky and built to take a beating, both from the operating environment and the users. They’re often power guzzlers, though, so knowing how to convert an industrial indicator for microcontroller use might be a handy skill to have.

Having decided that an Allen-Bradley cluster indicator worked with the aesthetic of his project, a Halloween prop of some sort, [Glen] set about dissecting the controls. Industrial indicators usually make that a simple task so that they can be configured for different voltages in the field, and it turned out that the easiest approach to replacing the power-hungry incandescent bulbs with LEDs was to build a tiny PCB to fit inside the four-color lens.

The uniquely shaped board ended up being too small for even series resistors for the LEDs, so a separate driver board was also fabbed. The driver board is set up to allow a single 5-volt supply and logic levels of 3.3-volt or 5-volt, making the indicator compatible with just about anything. The finished product lends a suitably sinister look to the prop.

If you’re not familiar with the programmable logic controllers such an indicator would be used with in the field, then maybe you should try running Pong on a PLC for a little background.