Building A Scooter Exhaust From Scrap Metal

June 23, 2020 by 20 Comments

When a part on a vehicle fails, oftentimes the response is to fit a new one fresh out the box. However, sometimes, whether by necessity or simply for the love of it, it’s possible to handcraft a solution instead. [Samodel] does just that when whipping up a new exhaust for his scooter out of scrap metal.

It’s a great example of classic backyard metalworking techniques. The flange is recreated using a cardboard template rubbed on the exhaust port, with the residual oil leaving a clear impression. Hard work with a grinder and drill get things started, with an insane amount of filing to finish the piece off nicely. A properly tuned pipe is then sketched out on the computer, and a paper template created. These templates are cut out of an old fridge to create the main muffler section.

There’s plenty of other hacks, too – from quick and dirty pipe bends to handy sheet forming techniques. It’s not the first time we’ve seen great metalworking with scrap material, either. Video after the break.

[Thanks to BrendaEM for the tip]

Continue reading “Building A Scooter Exhaust From Scrap Metal” →

Ask Hackaday: Is Our Power Grid Smart Enough To Know When There’s No Power?

June 23, 2020 by 63 Comments

Just to intensify the feeling of impending zombie apocalypse of the COVID-19 lockdown in the British countryside where I live, we had a power cut. It’s not an uncommon occurrence here at the end of a long rural power distribution network, and being prepared for a power outage is something I wrote about a few years ago. But this one was a bit larger than normal and took out much more than just our village. I feel very sorry for whichever farmer in another village managed to collide with an 11kV distribution pole.

What pops to mind for today’s article is the topic of outage monitoring. When plunged into darkness we all wonder if the power company knows about it. The most common reaction must be: “of course the power company knows the power is out, they’re the ones making it!”. But this can’t be the case as for decades, public service announcements have urge us to report power cuts right away.

In our very modern age, will the grid become smart enough to know when, and perhaps more importantly where, there are power cuts? Let’s check some background before throwing the question to you in the comments below.

Continue reading “Ask Hackaday: Is Our Power Grid Smart Enough To Know When There’s No Power?” →

Chaotic Oscillator From Antique Logic

June 23, 2020 by 35 Comments

While working on recreating an “ancient” (read: 60-year-old) logic circuit type known as resistor-transistor logic, [Tim] stumbled across a circuit with an unexpected oscillation. The oscillation appeared to be random and had a wide range of frequency values. Not one to miss out on a serendipitous moment, he realized that the circuit he built could be used as a chaotic oscillator.

Chaotic systems can be used for, among other things, random number generation, so making sure that they do not repeat in a reliable way is a valuable property of a circuit. [Tim]’s design uses LEDs in series with the base of each of three transistors, with the output of each transistor feeding into the input of the next transistor in line, forming a ring. At certain voltages close to the switching voltages of the transistors, the behavior of the circuit changes unpredictably both in magnitude and frequency.

Building real-life systems that exhibit true randomness or chaotic behavior are surprisingly rare, and even things which seem random are often not random enough for certain applications. [Tim]’s design benefits from being relatively simple and inexpensive for how chaotic it behaves, and if you want to see his detailed analysis of the circuit be sure to visit his project’s page.

If you want to get your chaos the old fashioned way, with a Chua circuit, look out for counterfeit multipliers.

USB-C Is Taking Over… When, Exactly?

June 23, 2020 by 179 Comments

USB is one of the most beloved computer interfaces of all time. Developed in the mid-1990s, it undertook a slow but steady march to the top. Offering an interface with good speeds and a compact connector, it became the standard for hooking up interface devices, storage, and even became the de-facto way to talk old-school serial, too.

In late 2014, the USB Implementers Forum finalised the standard for the USB-C plug. Its first major application was on smartphones like the Nexus 5X, and it has come to dominate the smartphone market, at least if you leave aside the iPhone. However, it’s yet to truly send USB-A packing, especially on the desktop. What gives? Continue reading “USB-C Is Taking Over… When, Exactly?” →

Switch Tester Servo-Slaps Them ’til They Fail

June 23, 2020 by 33 Comments

[James] is designing an open-source 3D printed keyboard switch, with the end goal of building a keyboard with as many printed parts as possible. Since keyswitches are meant to be pressed quite often, the DIY switches ought to be tested just as rigorously as their commercial counterparts are at the factory. Maybe even more so.

The broken spring after 13,000+ automated boings.

Rather than wear out his fingers with millions of actuations, [James] built a robot to test switches until they fail. All he has to do is plug a switch in, and the servo-driven finger slowly presses the slider down until the contacts close, which lights the LED.

The system waits 100ms for the contacts to stop any tiny vibrations before releasing the slider. That Arduino on the side tracks the contact and release points and sends them to the PC to be graphed. If the switch fails to actuate or release, the tester stops altogether.

We love that this auto-tester works just fine for commercial switches, too — the bit that holds the switch is separate and attaches with screws, so you could have one for every footprint variant. [James] recently did his first test of a printed switch and it survived an astonishing 13,907 presses before the printed coil spring snapped.

One could argue that this doubles as a servo tester. If you want a dedicated device for that, this one can test up to sixteen at a time.

Continue reading “Switch Tester Servo-Slaps Them ’til They Fail” →

OTA ESP32 GUI Makes Updates Simple

June 23, 2020 by 18 Comments

One of the disadvantages of having cheap WiFi-capable boards like those based on the ESP32 is that you have to update them. If you have even a few in every room of your house, it can be a pain to pull them out and connect them to a cable for programming. Over the air programming is a great answer, and [Kevin] shows how you can control the update via a simple GUI. You can see a video demonstration of how it works below.

[Kevin] uses a ready-made OTA library to do the work, but creates a GUI configuration and downloader tool. There is a manual step to force the board into the OTA mode, which might be a mild inconvenience, but it improves security since you need physical access to the device to do an update.

Continue reading “OTA ESP32 GUI Makes Updates Simple” →

New Silq Programming Language Aims To Make Quantum Programming Easier

June 22, 2020 by 18 Comments

Fresh from ETH Zurich comes the new Silq programming language. They also have submitted a paper to the PLDI 2020 conference on why they feel that it is the best quantum programming language so far. Although it may be not common knowledge, the lack of usable general purpose quantum computers has not kept multiple teams from developing programming languages for such computer systems.

Microsoft’s Q# is a strong contender in this space, along with the older QCL language. The claims by the Silq team on exactly why their language is better appear to come down to it being ‘more high level’, and by supporting automatic (and safe) uncomputation. While the ‘high level’ aspect is suspect since Q# is most decidedly a high-level programming language, their uncomputation claim does at least have some merit.

Quantum algorithm with uncompute step.

Uncomputation is a concept in quantum programming, where one occasionally has to remove a few intermediate objects from the current state because they may cause quantum interference that would affect the resulting output. Normally, one would save the intermediate result to a register for this, then reset the state and continue. Which parts of the state to keep and what to uncompute is however not easily determined, as a quick glance at related answers over at the Quantum Computing StackExchange and Theoretical Computer Science might reveal.

The main question thus appears the validity of this claim about Silq being able to automatically determine what ‘garbage’ can be safely uncomputed, and what should be part of the quantum interference. We have all seen with languages like Java and C# how even with traditional computing something as simple as garbage collecting can go horribly wrong. Maybe we shouldn’t count our quantum chickens yet until this particular waveform has fully collapsed.

(Thanks to Qes)