With all the trained academics who have pored over the Antikythera mechanism in the 120 years since it was pulled from the Mediterranean Sea, you’d think all of the features of the ancient analog computer would have been discovered by now. But the mechanism still holds secrets, some of which can only be appreciated by someone in tune with the original maker of the device. At least that what appears to have happened with the recent discovery of a hitherto unknown lunar calendar in the Antikythera mechanism.

The Antikythera mechanism is fascinating in its own right, but the real treat here is that this discovery comes from one of our own community — [Chris] at Clickspring, maker of amazing clocks and other mechanical works of art. When he undertook a reproduction of the Antikythera mechanism using nothing but period-correct materials and tools four years ago, he had no idea that the effort would take the direction it has. The video below — also on Vimeo — sums up the serendipitous discovery, which is based on the unusual number of divisions etched into one of the rings of the mechanisms. Scholars had dismissed this as a mistake, but having walked a mile in the shoes of the mechanism’s creator, [Chris] knew better.

The craftsmanship and ingenuity evidenced in the original led [Chris] and his collaborators to the conclusion that the calendar ring is actually a 354-day calendar that reflects a lunar cycle rather than a solar cycle. The findings are summarized in a scholarly paper in the Horological Journal. Getting a paper accepted in a peer-reviewed journal is no mean feat, so hats off to the authors for not only finding this long-lost feature of the Antikythera mechanism and figuring out its significance, but also for persisting through the writing and publication process while putting other projects on hold. Clickspring fans have extra reason to rejoice, too — more videos are now on the way!

source https://hackaday.com/2020/12/12/hackers-discovery-changes-understanding-of-the-antikythera-mechanism/

Being able to see, move, and exercise independently is something most of us take for granted. [Thomas Panek] was an avid runner before losing his sight due to a genetic condition, and had to rely on other humans and guide dogs to run again. After challenging attendants at a Google hackathon, Project Guideline was established to give blind runners (or walkers) independence from a cane, dog or another human, while exercising outdoors. Using a smartphone with line following AI software, and bone conduction headphones, users can be guided along a path with a line painted on it. You need to watch the video below to get a taste of just how incredible it is for the users.

Getting a wheeled robot to follow a line is relatively simple, but a running human is by no means a stable sensor platform. At the previously mentioned hackathon, developers put together a rough proof of concept with a smartphone, using its camera to recognize a painted line on the ground and provide left/right audio cues.  As the project developed, the smartphone was attached to a waist belt and bone conduction headphones were used,  which don’t affect audio situational awareness as much as normal headphones.

The shaking and side to side movement of running, and varying light conditions and visual obstructions in the outdoors made the problem more difficult to solve, but within a year the developers had completed successful running tests with [Thomas] on a well-lit indoor track and an outdoor pedestrian path with a temporary line. For the first time in 25 years, [Thomas] was able to run independently.

While guide dogs have proven effective for both daily life and running, they cost approximately $60000 over an average working life of 8 years, putting them out of reach of many sight-impaired people around the world. Project Guideline is still in the early stages, and real-world problems like obstacles and traffic still need to be addressed, but there is massive potential.

We’ve seen a few projects focused on helping the blind navigate obstacles, usually with haptic feedback, but this is the first we’ve seen that would allow independent running. Modern smartphones have incredible hacking potential, especially when you add machine learning to the mix.

source https://hackaday.com/2020/12/12/giving-blind-runners-independence-with-ai/

Compound bows (unlike recurve bows, their more mechanically-simple relatives) use a levering system with pulleys and spring tension to grant the user a mechanical advantage. We’re not exactly sure what to call [Zünder’s] bow design. He shared his unconventional take on a DIY bow that uses coiled springs as well as some other unique features.

What we really dig about [Zünder]’s design is how easy it is to grasp how it all works. As he demonstrates using the bow, the way the levers, pulleys, and spring tension all work together is very clear. The 3D-printed quiver and arrow rest are nice added touches, and we especially love the use of three toothbrush heads to provide contained support for a nocked arrow. The ring of bristles are sturdy enough to easily support the shaft, and don’t interfere with the arrow’s fletching.

[Zünder] has a photo gallery with a few additional photos and closeups, and you can watch him demonstrate his bow in the video embedded below.

We’ve seen some really clever DIY work when it comes to archery, like this effort at making a compound bow from PVC pipe, and this fascinating bicycle-wheel-based design that was built almost entirely from recycled and reused materials.

source https://hackaday.com/2020/12/12/slick-diy-compound-bow-uses-coiled-springs-toothbrush-heads/

A laser cutter is an incredibly useful tool and they are often found in maker spaces all over. They’re quite good at creating large two-dimensional objects and by cutting multiple flat shapes that connect together you can assemble a three-dimensional object. This is easier when creating something like a box with regular 90-degree angles but quickly becomes quite tricky when you are trying to construct any sort of irregular surface. [Tuomas Lukka] set out to create a dollhouse for his daughter using the laser cutter at his local hackerspace and the idea of creating all the joints manually was discouraging.

The solution that he landed on was writing a python script called Plycutter that can take in an STL file and output a series of DXF files needed by the cutter. It does the hard work of deciding how to cut out all those oddball joints.

At its core, the system is just a 3D slicer like you’d find for a 3D printer, but not all the slices are horizontal. Things get tricky if more than two pieces meet. [Tuomas] ran into a few issues along the way with floating-point round-off and after a few rewrites, he had a fantastic system that reliably produced great results. The dollhouse was constructed much to his daughter’s delight.

All the code for Plycutter is on GitHub. We’ve seen a similar technique that adds slots, finger-joints, and t-slots to boxes, but Plycutter really offers some unique capabilities.

source https://hackaday.com/2020/12/12/3d-finger-joints-for-your-laser-cutter/

A laser cutter is an incredibly useful tool and they are often found in maker spaces all over. They’re quite good at creating large two-dimensional objects and by cutting multiple flat shapes that connect together you can assemble a three-dimensional object. This is easier when creating something like a box with regular 90-degree angles but quickly becomes quite tricky when you are trying to construct any sort of irregular surface. [Tuomas Lukka] set out to create a dollhouse for his daughter using the laser cutter at his local hackerspace and the idea of creating all the joints manually was discouraging.

The solution that he landed on was writing a python script called Plycutter that can take in an STL file and output a series of DXF files needed by the cutter. It does the hard work of deciding how to cut out all those oddball joints.

At its core, the system is just a 3D slicer like you’d find for a 3D printer, but not all the slices are horizontal. Things get tricky if more than two pieces meet. [Tuomas] ran into a few issues along the way with floating-point round-off and after a few rewrites, he had a fantastic system that reliably produced great results. The dollhouse was constructed much to his daughter’s delight.

All the code for Plycutter is on GitHub. We’ve seen a similar technique that adds slots, finger-joints, and t-slots to boxes, but Plycutter really offers some unique capabilities.

source https://hackaday.com/2020/12/12/3d-finger-joints-for-your-laser-cutter/

A laser cutter is an incredibly useful tool and they are often found in maker spaces all over. They’re quite good at creating large two-dimensional objects and by cutting multiple flat shapes that connect together you can assemble a three-dimensional object. This is easier when creating something like a box with regular 90-degree angles but quickly becomes quite tricky when you are trying to construct any sort of irregular surface. [Tuomas Lukka] set out to create a dollhouse for his daughter using the laser cutter at his local hackerspace and the idea of creating all the joints manually was discouraging.

The solution that he landed on was writing a python script called Plycutter that can take in an STL file and output a series of DXF files needed by the cutter. It does the hard work of deciding how to cut out all those oddball joints.

At its core, the system is just a 3D slicer like you’d find for a 3D printer, but not all the slices are horizontal. Things get tricky if more than two pieces meet. [Tuomas] ran into a few issues along the way with floating-point round-off and after a few rewrites, he had a fantastic system that reliably produced great results. The dollhouse was constructed much to his daughter’s delight.

All the code for Plycutter is on GitHub. We’ve seen a similar technique that adds slots, finger-joints, and t-slots to boxes, but Plycutter really offers some unique capabilities.

source https://hackaday.com/2020/12/12/3d-finger-joints-for-your-laser-cutter/

We see more computers built from logic gates than you might expect. However, most of them are really more demonstration computers and can’t do much of what you’d consider essential today. No so with [Alastair Hewitt’s] Novasaur. Although built using 34 TLL chips (and a few memory and analog chips, too, along with one PAL), it boasts some impressive features:

• Dual Processor CPU/GPU (Harvard Architecture).
• 33 MHz dot clock, 16.5 MHz data path, 8.25 MHz per processor (~3.5 CPU MIPs)
• 256k ROM: 96k ALU, 64k native program, 64k cold storage, 32k fonts.
• 128/512k RAM: 1-7 banks of 64k user, 60k display, 4k system.
• 76 ALU functions including multiply/divide, system, and math functions.
• Bitmapped Graphics: Hi-res mode up to 416×240 with 8 colors and 4 dithering patterns. Lo-res mode up to 208×160 with 256 colors, double-buffered.
• Text Mode: 8 colors FG/BG, 256 line buffer, up to 104×60 using 8×8 glyphs, 80×36, and 64×48 rows using  8×16 glyphs.
• Audio: 4 voice wavetable synthesis, ADSR, 8-bit DAC, 8Hz-4.8kHz.
• PS2 Keyboard: Native interface built-in.
• RS232 Serial Port: Full duplex, RTS/CTS flow control, 9600 baud.
• Expansion Port: 7 addressable 8-bit register ports, 4 interrupt flags

The average speed (3.5 MIPS) is lower than the clock speed because some instructions take four clock cycles to execute. To save on devices, the ALU processes four bits at a time, requiring two cycles per math instruction. The internet interface is via the serial port, of course, so using this as your video streaming server is probably not a good idea.

Still, not too shabby for a handful of generic parts. One problem with this type of CPU is developing all the software. The Novasaur has a byte-code interpreter that can execute 8080 and 8085 code directly, solving that problem neatly.

Of course, you can’t see a TTL computer without thinking of the Gigatron. Then there’s the infamous breadboard computer.

source https://hackaday.com/2020/12/11/surfing-the-web-with-7400-logic/

If you were to plumb the depth of the oceans, you could only get so far with a snorkel or a SCUBA tank. We don’t know the price, but if you have enough money, you might consider the Triton 3300/6 — a six-person submersible that can go down to 3,300 feet (hence the name–get it–3300/6). Billed as “diving for the entire family,” we aren’t sure we can load grandma and the kids in something like this, but that doesn’t mean we wouldn’t like to try.

The machine can carry up to 1,760 pounds and can make 3 knots which isn’t going to set any speed records. At around 24,000 pounds, the two main thrusters are lucky to make that speed. The view bubble is apparently optically perfect acrylic made by a German company and the company claims the 100-inch diameter bubble is the world’s largest spherical acrylic pressure hull.

The 3,300-foot depth sounds impressive and is much further than you can get with conventional SCUBA gear. However, keep in mind the deepest part of the ocean is nearly 36,000 feet down, and you only have 10 hours of operations, so keep your expectations realistic. Even the ocean’s average depth is about 12,000 feet.

We have to admit the thing looks cool, but we couldn’t find the price since it is probably one of those things that if you have to ask, you can’t afford it. It did make us wonder, though, if anyone has tried their hand at a crewed submersible? There are some technical hurdles. You’d want bulletproof life support and backup systems. Water gets into everything and you probably need an emergency surface capability and maybe want to go down with SCUBA gear the first few attempts. But still. We see things at least this dangerous all the time.

We haven’t seen many attempts, although there was one that had few details (the web site is gone, but the videos remain). There are plenty of ways to track your progress from the topside if you decide to have a go at it.

source https://hackaday.com/2020/12/11/a-thousand-feet-under-the-sea/

Over the last 2 years [Carl Bujega] has made a name for himself with his PCB motor designs. His latest adventure is to turn it into a stepper motor by adding position control with microstepping.

The NEMA stepper motors most of us know are synchronous stepper motors, while [Carl]’s design is a permanent magnet design. It uses four coils on the stator, and two permanent magnets on the rotor/dial. By varying the current through each of the four poles with a stepper driver (microstepping), the position of the rotor should theoretically be controllable with good resolution. Unfortunately, this was easier said than done. He achieved position control, but it kept skipping steps in certain positions.

The motor and controller consist of a single flexible PCB, to reduce the layer spacing and increase the coils’ magnetic field strength. However, this created other problems, since the motor shaft didn’t have a solid mounting point, and the PCB flexed as the stator coils were energized. Soldering the controller was also a problem, as the through-hole headers ripped out easily and the PCB bulged while reflowing on a hot plate, in one case even popping off components. [Carl] eventually mounted one of the PCB motors inside a 3D printed frame to rigidly constrain all the motor components, but it still suffered from missed steps. Any suggestions for fixing the problem? Drop them in the comments below.

Like his other PCB motors, the torque is very low, but should be suitable for gauges or clocks. A PCB clock with an integrated motor would be pretty cool to have on the workshop wall.

The TMC2300 stepper driver [Carl] used belongs to the same family of drivers that enable silent stepping for 3D printers. We’ve covered a few of [Carl]’s PCB actuator adventures, from his original design to linear actuators and a flexible POV display.

source https://hackaday.com/2020/12/11/microstepping-a-pcb-motor/

At this point if you’re even remotely interested in home laser cutters, you know about the K40. These imported machines are very impressive considering they only cost around $400 USD, but naturally, quite a few corners had to be cut to get the price down. If you’re looking for something with a bit more punch and much higher build quality, a new breed of 60 watt lasers have started popping up on the usual import sites for around $2,000 USD.

While these more expensive machines are certainly much higher quality than the K40, [Jeremy Cook] found there was still plenty of room for improvement. For example, the machine didn’t have any switch cut off the laser when somebody opens the lid. While we don’t doubt some readers will consider this more of a feature than a bug, it’s hard to believe that any tool with a five figure price tag wouldn’t at least offer such a thing as an option.

[Jeremy] also decided to add his own ammeter so he could see how much power the laser is drawing. While not strictly required for day to day operation, it turns out that the controller in many of these machines has a tendency to push the laser tubes beyond their design limits on the higher power settings. With the spec sheet for your tube and a permanent in-line ammeter, you can verify you aren’t unwittingly shortening the life of your new cutter.

Even if you ignore the modifications [Jeremy] makes in his video, it’s still a very illuminating look at what it takes to get one of these lasers ready for operation. Not only do you have to get the thing out of its shipping crate safely, but you need to come up with some way to deal with the fumes produced and get the water cooling system hooked up. It’s a decent amount of work, but the end results certainly look impressive.

While the K40 is still probably the better bet for new players, it’s good to see that there are some viable upgrades for anyone who’s outgrown their entry level machine but isn’t in a position to spend the money on an Epilog.

source https://hackaday.com/2020/12/11/putting-the-finishing-touches-on-a-60w-laser/

There was a time during the early years of mass digital photography, when a film scanner was a common sight. A small box usually connected to a USB port, it had a slot for slides or negatives. In 2020 they’re  a rare breed, but never fear! [Bezineb5] has a solution in the shape of an automated scanner using a Radpberry Pi and a mechanism made of Lego.

The Lego mechanism is a sprocket feeder that moves the film past the field of view from an SLR camera. The software on the Pi runs in a Docker container, and features a machine learning approach to spotting frame boundaries. This is beyond the capabilities of the Pi, so is offloaded to a Google Coral accelerator.

The whole process is automated with the Pi controlling not only the Lego but also the camera, to the extent of retrieving the photos from it to the Pi. There’s a smart web interface to control everything, making the process — if you’ll excuse the pun — a snap. There’s a video of it in action, that you can see below the break.

We’ve featured many film scanner projects over the years, one that remains memorable is this 3D printed lens mount.

Via r/raspberry_pi.

source https://hackaday.com/2020/12/11/still-got-film-to-scan-this-lego-and-raspberry-pi-scanner-is-for-you/

There’s a VMWare problem that’s being exploited in the wild, according to the NSA (PDF). The vulnerability is a command injection on an administrative console. The web host backing this console is apparently running as root, as the vulnerability allows executing “commands with unrestricted privileges on the underlying operating system.”

The wrinkle that makes this interesting is that VMWare learned about this vuln from the NSA, which seems to indicate that it was a zero-day being used by a foreign state. The compromise chain they list is also oddly specific, making me suspect that it is a sanitized account of observed attacks.

Microsoft Teams, And the Non-CVE

[Oskars Vegeris] found a pair of interesting problems in the Microsoft Teams client, which together allows an interactionless, wormable RCE. The first vuln is an XSS problem, where a message containing a “mention” can be modified in transit to include arbitrary Javascript. To get that JS past the XSS protection filter, a unicode NULL byte is included in the payload. The second vuln is using the built-in file download code in the Teams app to download and auto-run a binary. Put together, anyone who simply loads the message in their Teams app runs the code.

Vegeris points out that since so many users have a presence in multiple rooms, it would be trivial to use this exploit to build a worm that could infect the majority of Teams users worldwide. The bug was reported privately to Microsoft and fixed back in October. A wormable RCE in a widely used tool seems like a big deal, and should net a high CVE score, right? Microsoft gave two ratings for this attack chain, for the two versions of Teams that it can affect. For the Office365 client, it’s “Important, Spoofing”, which is about as unimportant as a bug can be. The desktop app, at least, was rated “critical” for an RCE. The reason for that seems to be that the sandbox escape only works on the standalone desktop app.

But no CVE was issued for the exploit chain. In the security community, collecting CVEs is an important proof of work for your resume. Microsoft replied that they don’t issue CVEs for products that get updated automatically without user interaction. Kerfuffle ensued.

Fuzzing with Atheris

Google released Atheris, a new open-source fuzzing tool, specifically written for Python programs. Fuzzing is the process of running a program or library with generated input, usually input that would be considered malformed, and tracking what happens. Many vulnerabilities have been found and fixed this way in recent years. Atheris is a coverage-guided fuzzer, meaning it keeps track of which lines of code are executed in each iteration, and tries to maximize the lines covered.

The announcement post points out a fascinating use case for Atheris — testing two implementations of a library for bug-for-bug compatibility. An example might be a JSON parser written in Python, compared to a browser’s version. You would set up a test run that started with valid JSON, and then transforms that input slightly for each iteration. Run the same input through both implementations, and then compare the outputs.

Not to be outdone, Intel also just announced a bug-finding tool, ControlFlag. This tool operates on a very different principle, using machine learning to find anomalies in written source code. I wish I could tell you the source is available to go play with, but it appears that this tool has been announced only, and not released for public use.

SSL Root Cert Abuse

Kazakhstan seems to be engaging in some strange security practices, likely intended to enable snooping on internet traffic. ISPs in the capital city are blocking access to Google, Twitter, and the like, until a government issued root certificate is installed and trusted in the connecting browser. The government is calling this a “training exercise”, but as the certificate is valid for 20 years, it seems like a blatant attempt to enable HTTPS MitM attacks against the public. Stories like this are a reminder of how important things like OCSP stapling and DNS Certification Authority Authorization are. Both of those protocol extensions are intended to protect users from fraudulent certificates that are issued by a trusted root certificate.

Trickbot Evolves and Gains a New Skill

The Trickbot malware platform is an all-in-one tool for stealing credentials, controlling bots, and installing ransomware. It seems a new trick is being added to the already-overflowing bag — firmware modification. The core library from RWEverything has been found in recent samples of Trickbot, and the malware has been observed doing recon against machine firmware. So far, no one has observed a malicious firmware write by Trickbot, but the capability is now there, and that’s worrying enough.

source https://hackaday.com/2020/12/11/this-week-in-security-vmware-microsoft-teams-python-fuzzing-and-more/

Pandemic lockdowns have been brutal, but they’ve had the side-effect of spurring creativity and undertaking projects that are involved enough and complex enough to keep from going stir crazy. This CNC string art robot is a great example of what’s possible with a little imagination and a lot of time. (Video, embedded below.)

According to [knezuld11], the robot creates its art through mathematical algorithms via a Python program that translates them into nail positions and string paths. The modified CNC router frame, constructed of laser-cut plywood, has two interchangeable tool heads. The first places the nails, which are held in a small hopper. After being picked up by a servo-controlled magnetic arm and held vertically, a gear-driven ram pushes each nail into a board at just the right coordinates. After changing to a different tool, the robot is able to pick up one of nine different thread dispensers. A laser sensor verifies the thread nozzle position, and the thread starts its long journey around the nails. It’s a little mesmerizing to watch, and the art looks great, with a vibe that brings us right back to the 70s. Groovy, man.

This reminds us a little of a recent [Barton Dring] project that makes art from overlapping strings. That one was pretty cool for what it accomplished with just one thread color, while this one really brings color to the party. Take your pick, place your nails, and get stringing.

[Clint Jay] sent us the tip on this one. Thanks!

source https://hackaday.com/2020/12/11/cnc-router-frame-repurposed-for-colorful-string-art-bot/

What is it about larger-than-life versions of things that makes them so awesome? We’re not sure exactly, but this giant working Arduino definitely has the ‘it’ factor, whatever that may be. It’s twelve times the size of a regular Uno and has a Nano embedded in the back of it. To give you an idea of the scale, the reset button is an arcade button.

The Arduino Giga’s PCB is made of 3/4″ plywood, and the giant components represent a week and a half of 3D printing. The lettering and pin numbers are all carved on a CNC and filled in with what appears to be caulk. They didn’t get carved out deeply enough the first time around, but [byte sized] came up with a clever way to perfectly re-register the plywood so it carved in exactly the same places.

Although we love everything about this build, our favorite part has to be the way that [byte sized] made the female headers work. Each one has a 1/4″ audio jack embedded inside of it (a task which required a special 3D printed tool), so patch cables are the new jumper cables. [byte sized] put it to the test with some addressable RGB LEDs on his Christmas tree, which you can see in the build video after the break.

You can buy one of those giant working 555 timer kits, but why not just make one yourself?

source https://hackaday.com/2020/12/11/gigantic-working-arduino-uses-1-4-cables/

If you follow retrcomputing — or you are simply old enough to remember those days — you hear the same names over and over. Commodore, Apple, Radio Shack, and Sinclair, for example. But what about the Lambda 8300? Most people haven’t heard of these but [Mike] has and he has quite a few of them. The computer is similar to a Sinclair ZX81, but not an exact clone. All of his machines need some repairs (he’s promised repair videos are on their way), but for the video below he wired a monitor directly to the PCB to get steady output, so apparently the RF modulator is the failing subsystem in this case.

Once the video cleared up, you can see a walkthrough of running a simple BASIC program. As was common in those days, the computer used an audio cassette recorder for data storage. [Mike] picked up some dedicated recorders meant for computer use, but neither were in working shape. However, a consumer player works fine.

Cassettes are not very reliable, so [Mike] loads the audio into his phone and then uses it for future loads. We were titillated by the quick teardown and wanted to see more, but [Mike] says there are at least two more videos on the way so we guess we’ll have to freeze the video to gawk at the board until they arrive.

These machines were made to be cheap, so the CPU did everything. Keyboard I/O, screen output, and the cassette interface were all directly tied to the CPU with as little hardware assistance as possible. The Sinclair machine was also famous for this, and that made them peculiar to operate as you’ll see in the video. In the United States, these computers were branded as “Your Computer PC 8300” and “Unisonic Futura 8300.” They were sold under other names in different markets but were not as successful as the Sinclair and its direct relatives which reportedly sold about 1.5 million units.

On the one hand, these cheap machines probably launched a lot of budding young programmers. But you also have to wonder how many were opened on Christmas morning and were jammed in the back of a closet, forgotten, by New Year’s?

We haven’t seen any Lambda 8300 emulations, but it was close enough to a ZX81 and those do exist. You can find people still working on these machines, connecting them to the Internet and producing add-on boards.

 

source https://hackaday.com/2020/12/10/a-lambda-8300-lives-again/

We were struck by how attractive [mircemk’s] Arduino-based frequency counter looks. It also is a reasonably simple build. It can count up to 6.5 MHz which isn’t that much, but there’s a lot you can do even with that limitation.

The LED display is decidedly retro. Inside a very modern Arduino Nano does most of the work. There is a simple shaping circuit to improve the response to irregular-shaped input waveforms. We’d have probably used a single op-amp as a zero-crossing detector. Admittedly, that’s a bit more complex, but not much more and it should give better results.

There was a time when a display like this would have meant some time wiring, but with cheap Max 7219 board available, it is easy to add a display like this to nearly anything. An SPI interface takes a few wires and all the hard work and wiring is done on the module.

The code is short and sweet. There are fewer than 30 lines of code thanks to LED drivers and a frequency counter component borrowed from GitHub.

If you add a bit more hardware, 100 MHz is an easy target. There are at least three methods commonly used to measure frequency. Each has its pros and cons.

source https://hackaday.com/2020/12/10/easy-frequency-counter-looks-good-reads-to-6-5-mhz/

We probably don’t need to tell the average Hackaday reader that the ESP32 is a powerful and extremely flexible microcontroller. We’ve seen some incredible projects using this affordable chip over the last few years, and by the looks of it, the best is yet to come. That’s because it always takes some time before the community can really figure out how to get the most out of a piece of hardware.

Take for example the Bluetooth audio player that [squix] was recently working on. Getting the music going was no problem with the esp32-a2dp library, but when he wanted to add some visualizations the audio quality took a serious hit. Realizing that his Fast Fourier transform (FFT) code was eating up too much processor power, it seemed like a great time for him to explore using the ESP32’s second core.

[squix] had avoided poking around with the dual-core nature of the ESP32 in the past, believing that the second core was busy handling the WiFi communication. But by using the FreeRTOS queue system, he wrote some code that collects audio data with one core and runs the actual FFT magic on the other. By balancing the workload like this, he’s able to drive the array of 64 WS2812B LEDs on the front of the Icon64 seen in the video after the break.

Even if you’re not terribly interested in running your own microcontroller disco, this project may be just the example you’ve been waiting for to help get your mind wrapped around multitasking on the ESP32. If you want to master a device with this many tricks up its sleeve, you’ll need all the help you can get.

source https://hackaday.com/2020/12/10/esp32-spectrum-analyzer-taps-into-both-cores/

The idea of a reconfigurable macro keyboard is a concept that has been iterated on by many all the way from custom DIY keypads to the polarizing TouchBar on MacBooks. The continual rise of cheap powerful microcontrollers with Wi-Fi and 3D printers makes rolling your own macro keyboard easier every year. [Dustin Watts] has joined the proverbial club and built a beautiful macro pad called FreeTouchDeck.

We’ve seen macro keyboards that use rotary encoders to cycle through different mappings for the keys. FreeTouchDeck has taken the display approach and incorporates a touch screen to offer different buttons. [Dustin] was inspired by a similar project called FreeDeck, which offers six buttons each with a small screen. FreeTouchDeck is powered by an ESP32 and drives an ILI9488 touch screen with an XPT2046 touch controller. This means that FreeTouchDeck can offer six buttons with submenus and all sorts of bells and whistles. A connection to the computer is done by emulating a Bluetooth keyboard. By adding a configuration mode that starts a web server, FreeTouchDeck allows easy customization on the fly.

[Dustin] whipped up a quick PCB that makes it easy to solder the ESP32 and the TFT together, but a breadboard works just fine. Gerbers for that are available on GitHub. To wrap it all up, a nice 3D printed shell encloses the whole system in a clean, tidy way. The code, documentation, and case designs are all on his GitHub.

Thanks [Dustin] for sending this one our way!

source https://hackaday.com/2020/12/10/the-macro-keyboard-is-on-deck/

It’s usually the simple ideas that sprout bigger ones, and this was the case when we saw [gzumwalt]’s single-motor walking robot crawling up a fridge door with magnets on its feet. (Video, embedded below.)

The walking mechanism consists of an inner foot and two outer feet, connected by three sets of rotating linkages, driven by a single geared motor. The feet move in a leapfrog motion, in small enough steps that the center of mass always stays inside the foot area, which keeps it from tipping over. Besides the previously mentioned ability to crawl around on a vertical magnetic surface, it’s also able to crawl over almost any obstacle shorter than its step length. A larger version should also be able to climb stairs.

As shown, this robot can only travel in a straight line, but this could be solved by adding a disc on the bottom of the inner foot to turn the robot when the outer feet are off the surface. Add some microswitch feelers and an Arduino, and it can autonomously explore your fridge without falling off. Maybe we’ll get around to building it ourselves, but be sure to drop us a tip if you beat us to it!

[gzumwalt] is a master of 3D printed devices like a rigid chain and a domino laying robot. The mechanism for this robot was inspired by one design from [thang010146]’s marvelous video library of mechanisms.

source https://hackaday.com/2020/12/10/a-walking-rover-destined-explore-your-fridge-door/

There are a great variety of ways to build a random number generator, and similarly many ways to generate numbers that appear random, but in a pure mathematical sense generally aren’t. [Daniel Valuch] built a Christmas decoration that does the latter, displaying the results on an attractive flashing ornament.

The build relies on a 16-bit linear feedback shift register, or LFSR. The LFSR generates a stream of numbers, with each number dependent on the previous state of the register. Thus, the numbers generated are pseudorandom, not truly random, and depend on the initial seed value of the system. [Daniel] built the shift register using relays, which create a lovely clacking sound as the register operates, and LEDs, which glow depending on the values in the register.

The result is a cute Christmas ornament that blinks in a deterministic fashion, and has a great old-school look due to the exposed copper of the PCB and the retro LED colors used. The project also serves as a great way to learn about shift registers and basic relay logic, though the latter is rarely used these days for serious purposes. We’ve covered the topic before, too. Video after the break.

source https://hackaday.com/2020/12/09/a-relay-based-pseudorandom-number-generator/

[Gijs Gieskes] has made another eye-catching PCB wonder, this time a diary built from several circuit boards which are assembled into a book, not unlike a PC/104 system. But with [Gijs]’s system you can easily open the stack-up to access single boards without disassembling the whole thing. We don’t see brass piano hinges on PCB assemblies very often, but [Gijs]’s PCB designs are anything but conventional. Hint: if you wanted to recreate this technique using more ordinary hardware, you can find hinged PCB standoffs from various suppliers.

Apparently it’s more than a passive piece of art.  Each board has several circuits, some of which (all?) are functioning is ways not clearly described, which seems to be intentional. According to his build log, different things happen when you mix and match the inter-board ribbon cables in various ways. We are told in the instructions “to just try and see what happens”. No schematics are posted, but there is a partial description of the circuits in the manual and parts on the two-layer boards are well-labeled. Although after spot checking a few circuits board photos, we’d guess that no small number of traces, and perhaps some parts, are wild goose chases.

The project claims to be a diary for the years 2018 and 2019, but we will leave it as an exercise for the reader to interpret the messages that [Gijs] has embedded into this fascinating piece. We have written about several of his projects over the years, such as this crazy bent Casio SK-1 from all the way back in 2005. And before dismissing this “book” style of circuit board stack-up as only for artists, check out this teardown of a Soyuz clock we covered back in January.

source https://hackaday.com/2020/12/09/a-pcb-diary/

[Gijs Gieskes] has made another eye-catching PCB wonder, this time a diary built from several circuit boards which are assembled into a book, not unlike a PC/104 system. But with [Gijs]’s system you can easily open the stack-up to access single boards without disassembling the whole thing. We don’t see brass piano hinges on PCB assemblies very often, but [Gijs]’s PCB designs are anything but conventional. Hint: if you wanted to recreate this technique using more ordinary hardware, you can find hinged PCB standoffs from various suppliers.

Apparently it’s more than a passive piece of art.  Each board has several circuits, some of which (all?) are functioning is ways not clearly described, which seems to be intentional. According to his build log, different things happen when you mix and match the inter-board ribbon cables in various ways. We are told in the instructions “to just try and see what happens”. No schematics are posted, but there is a partial description of the circuits in the manual and parts on the two-layer boards are well-labeled. Although after spot checking a few circuits board photos, we’d guess that no small number of traces, and perhaps some parts, are wild goose chases.

The project claims to be a diary for the years 2018 and 2019, but we will leave it as an exercise for the reader to interpret the messages that [Gijs] has embedded into this fascinating piece. We have written about several of his projects over the years, such as this crazy bent Casio SK-1 from all the way back in 2005. And before dismissing this “book” style of circuit board stack-up as only for artists, check out this teardown of a Soyuz clock we covered back in January.

source https://hackaday.com/2020/12/09/a-pcb-diary/

[Gijs Gieskes] has made another eye-catching PCB wonder, this time a diary built from several circuit boards which are assembled into a book, not unlike a PC/104 system. But with [Gijs]’s system you can easily open the stack-up to access single boards without disassembling the whole thing. We don’t see brass piano hinges on PCB assemblies very often, but [Gijs]’s PCB designs are anything but conventional. Hint: if you wanted to recreate this technique using more ordinary hardware, you can find hinged PCB standoffs from various suppliers.

Apparently it’s more than a passive piece of art.  Each board has several circuits, some of which (all?) are functioning is ways not clearly described, which seems to be intentional. According to his build log, different things happen when you mix and match the inter-board ribbon cables in various ways. We are told in the instructions “to just try and see what happens”. No schematics are posted, but there is a partial description of the circuits in the manual and parts on the two-layer boards are well-labeled. Although after spot checking a few circuits board photos, we’d guess that no small number of traces, and perhaps some parts, are wild goose chases.

The project claims to be a diary for the years 2018 and 2019, but we will leave it as an exercise for the reader to interpret the messages that [Gijs] has embedded into this fascinating piece. We have written about several of his projects over the years, such as this crazy bent Casio SK-1 from all the way back in 2005. And before dismissing this “book” style of circuit board stack-up as only for artists, check out this teardown of a Soyuz clock we covered back in January.

source https://hackaday.com/2020/12/09/a-pcb-diary/

Since the late 60s, Moore’s law has predicted with precision that the number of semiconductors that will fit on a chip about doubles every two years. While this means more and more powerful computers, every year, it also means that old computers can be built on smaller and cheaper hardware. This project from [Bjoern] shows just how small, too, as he squeezes a PET 2001 onto the STM32 Blue Pill.

While the PET 2001 was an interesting computer built by Commodore this project wasn’t meant to be a faithful recreation, but rather to test the video output of the Blue Pill, with the PET emulation a secondary goal. It outputs a composite video signal which takes up a good bit of processing power, but the PET emulation still works, although it is slightly slow and isn’t optimized perfectly. [Bjoern] also wired up a working keyboard matrix as well although missed a few wire placements and made up for it in the software.

With his own home-brew software running on the $2 board, he has something interesting to display over his composite video output. While we can’t say we’d emulate an entire PC just to get experience with composite video, we’re happy to see someone did. If you’d like to see a more faithful recreation of this quirky piece of computing history, we’ve got that covered as well.

source https://hackaday.com/2020/12/09/pet-2001-emulator-on-2-of-hardware/

On Tuesday, December 8th, Red Hat and CentOS announced the end of CentOS 8. To be specific, CentOS 8 will reach end of life at the end of 2021, 8 years ahead of schedule. To really understand what that means, and how we got here, it’s worth taking a trip down memory lane, and looking at how the history of Red Hat Enterprise Linux (RHEL), CentOS, and IBM are intertwined.

First, History

Red hat started way back in 1995, with the partnership between Bob Young and Marc Ewing. Ewing brought his nascent Linux distro, named Red Hat Linux after the fedora red lacrosse cap Ewing was known for wearing. Red Hat Linux quickly introduced a set of killer features, such as the Red Hat Package Manager (RPM), the Anaconda installer, and ELF binaries, to name a few. By 2003, Red Hat Linux was split into two separate distros, RHEL and Fedora Core. RHEL was the subscription-only distribution, while Fedora Core was the bleeding-edge distribution available for free. Just a note, I was running Fedora on my machines since before they dropped “Core” from the name.

The RHEL product, while open source, is only available for paid subscribers, or developers in non-production environments. Because it’s open source, there is nothing preventing a third party from removing the branding, and recompiling the packages for free. This is exactly what Gregory Kurtzer and the other founding members of CentOS did back in 2004. CentOS version 2 was the first such release, bringing an Enterprise Linux to the Community.

The next bit of history we have to cover was in 2009, when Lance Davis went missing from the project. This was a problem, because Davis held the project domain registrations, the donations fund, and some of the other intellectual property of the project. There was a possibility that this would kill the project, but Davis finally responded to a published open letter from the project, and agreed to hand over control. Crisis averted.

Becoming Respectable

In 2014, an important change was announced. Red Hat would officially sponsor CentOS. Several of the core CentOS team would go full time on the Red Hat payroll, Red Hat got a trio of seats on the governing board, and most importantly, the community was assured that “The CentOS Linux platform isn’t changing.” It wasn’t made entirely clear, but part of the deal included transferring the CentOS trademarks and IP to Red Hat for safe keeping.

This arrangement worked out well for years. CentOS 8 shipped September 2019, rapidly after RHEL 8, and CentOS Stream was announced and released as an early look at what was coming in the next minor update. CentOS Stream could be thought of as a polished beta channel.

IBM bought Red Hat in 2019. Part of the announcement was a promise that Red Hat would stay true to its Open Source roots, claiming that “Red Hat’s mission and unwavering commitment to open source will remain unchanged.” Even with such assurances, many users were concerned that the IBM acquisition would fundamentally alter the way Red Hat does businesses for the worse.

Where Are We Now

With this context in mind, the recent news is troubling. Many of us have deployed CentOS servers to production environments, trusting Red Hat’s promise that CentOS 8 would be supported through 2029. The Red Hat announcement means that those installs reach end of life after less than 2 years, with the only upgrade path being Centos Stream — AKA being a forced beta tester for RHEL. As you might imagine, the response from the community has not been positive. We feel betrayed and lied to. It’s unclear whether this decision was handed down from IBM, or was cooked up by Red Hat themselves. In any case, it’s become painfully clear that handing over control of CentOS was a terrible mistake.

For those of us who prefer RPM based systems, where does that leave us? Fedora is great, but the rapid development cadence is terrible for server deployment. OpenSUSE Leap is a rebuild of SUSE Linux Enterprise Server, much like CentOS, and is a viable option for new deployments.

In the comments on the CentOS announcement, Gregory Kurtzer asked for users and developers interested in a reboot to check in on one of his slack channels. Within 8 hours, over 250 of us showed up, wanting to make a CentOS replacement happen. I’ve talked directly with Gregory, and can confirm that a new community rebuild of RHEL is happening under the name Rocky Linux, in honor of one of another CentOS co-founder that has passed away. The plan is to support a direct transition path from CentOS to Rocky Linux.

Rocky Linux will be bug-for-bug compatible with RHEL. It will be CentOS as it was before the Red Hat takeover, just under a new name. I’m excited to see where the project goes, and hopeful to see an initial release in the following months. When it happens, we’ll be sure to tell you about it.

source https://hackaday.com/2020/12/09/centos-is-dead-long-live-centos/