url stringlengths 37 208 | title stringlengths 4 148 | author stringclasses 173
values | publish_date stringclasses 1
value | categories listlengths 0 12 | tags listlengths 0 27 | featured_image stringlengths 0 272 | content stringlengths 0 56.1k | comments_count int64 0 900 | scraped_comments_count int64 0 50 | comments listlengths 0 50 | scraped_at float64 1.76B 1.76B |
|---|---|---|---|---|---|---|---|---|---|---|---|
https://hackaday.com/2020/12/09/a-relay-based-pseudorandom-number-generator/ | A Relay-Based Pseudorandom Number Generator | Lewin Day | [
"Holiday Hacks"
] | [
"blinky",
"christmas ornament",
"linear feedback shift register"
] | 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. | 10 | 3 | [
{
"comment_id": "6302049",
"author": "tilk",
"timestamp": "2020-12-10T08:17:13",
"content": "You probably meant to link to this video:https://www.youtube.com/watch?v=6Pp9ys1MGVsThe numbers displayed in the linked video are clearly not quite random ;)",
"parent_id": null,
"depth": 1,
"rep... | 1,760,373,259.058685 | ||
https://hackaday.com/2020/12/09/a-pcb-diary/ | A PCB Diary | Chris Lott | [
"Art"
] | [
"hinge pcb",
"pc/104",
"pcb art"
] | [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.
Bicycle, soccer ball, smoke on the “No no no no no…” PCB
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. | 8 | 5 | [
{
"comment_id": "6301993",
"author": "Ren",
"timestamp": "2020-12-10T03:22:14",
"content": "Neat idea!In true diary form, one could show the progression of their electronics/computer knowledge over the years.My first page would probably an electric bicycle horn I bought in the 3rd grade. Then, tear... | 1,760,373,258.750955 | ||
https://hackaday.com/2020/12/11/cnc-router-frame-repurposed-for-colorful-string-art-bot/ | CNC Router Frame Repurposed For Colorful String Art Bot | Dan Maloney | [
"Art",
"cnc hacks"
] | [
"art",
"cnc",
"String Art",
"tool changer"
] | 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! | 12 | 10 | [
{
"comment_id": "6302391",
"author": "Will",
"timestamp": "2020-12-11T12:15:48",
"content": "This is so awesome",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6302573",
"author": "Dany Lipsker",
"timestamp": "2020-12-12T06:15:30",
"co... | 1,760,373,259.014528 | ||
https://hackaday.com/2020/12/11/gigantic-working-arduino-uses-1-4-cables/ | Gigantic Working Arduino Uses 1/4″ Cables | Kristina Panos | [
"Arduino Hacks"
] | [
"arduino",
"arduino giga",
"arduino maxi",
"arduino nano",
"audio jacks",
"patch cables"
] | 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? | 25 | 14 | [
{
"comment_id": "6302361",
"author": "JanW",
"timestamp": "2020-12-11T09:24:36",
"content": "You should simply delete hackaday from your bookmarks then.You’ll find a site where there is only news that’s interesting to you, I’m sure!Goodbye!",
"parent_id": null,
"depth": 1,
"replies": [
... | 1,760,373,258.817056 | ||
https://hackaday.com/2020/12/10/a-lambda-8300-lives-again/ | A Lambda 8300 Lives Again | Al Williams | [
"Retrocomputing",
"Teardown"
] | [
"Lambda 8300",
"sinclair zx81",
"z80",
"Z80A",
"zx81"
] | If you follow retrocomputing — 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
. | 3 | 3 | [
{
"comment_id": "6302343",
"author": "Jørgen Tester",
"timestamp": "2020-12-11T07:23:09",
"content": "It would be over cool if someone could dig out the actual page of Politiken (these probably exist only on microfilm ?) and copy the listing as a PDF.There is an article (in Danish) about the compute... | 1,760,373,258.529529 | ||
https://hackaday.com/2020/12/10/easy-frequency-counter-looks-good-reads-to-6-5-mhz/ | Easy Frequency Counter Looks Good, Reads To 6.5 MHz | Al Williams | [
"Arduino Hacks",
"Tool Hacks"
] | [
"arduino",
"frequency counter",
"MAX 7219",
"MAX7219"
] | 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. | 12 | 5 | [
{
"comment_id": "6302333",
"author": "Cyna",
"timestamp": "2020-12-11T06:14:47",
"content": "Lacking schematic, but at least a bit of HP and afterwards LP filtering along with limited input protection (not that many of his targeted readers are likely to identify those components).",
"parent_id":... | 1,760,373,258.863544 | ||
https://hackaday.com/2020/12/10/esp32-spectrum-analyzer-taps-into-both-cores/ | ESP32 Spectrum Analyzer Taps Into Both Cores | Tom Nardi | [
"digital audio hacks",
"LED Hacks",
"Microcontrollers"
] | [
"bluetooth",
"Bluetooth A2DP",
"bluetooth speaker",
"ESP32",
"spectrum analyzer"
] | 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. | 16 | 7 | [
{
"comment_id": "6302290",
"author": "Mike Massen, Perth Western Australia",
"timestamp": "2020-12-11T00:16:09",
"content": "Cool, thanks for post, nice to see more products and research on this platform, thanks",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6... | 1,760,373,258.639545 | ||
https://hackaday.com/2020/12/10/the-macro-keyboard-is-on-deck/ | The Macro Keyboard Is On Deck | Matthew Carlson | [
"Microcontrollers",
"Peripherals Hacks",
"Wireless Hacks"
] | [
"ESP32",
"ILI9488",
"macro keyboard",
"touch screen",
"XPT2046"
] | 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! | 2 | 2 | [
{
"comment_id": "6302425",
"author": "Ren",
"timestamp": "2020-12-11T14:27:32",
"content": "I was interested, but then, I thought it was only for social media applications, but then, I thought, “Oh! It can be used for Excel macros as well!”",
"parent_id": null,
"depth": 1,
"replies": []
... | 1,760,373,258.490276 | ||
https://hackaday.com/2020/12/10/remoticon-video-learn-how-to-hack-a-car-with-amith-reddy/ | Remoticon Video: Learn How To Hack A Car With Amith Reddy | Dan Maloney | [
"cons",
"Transportation Hacks"
] | [
"2020 Remoticon",
"CAN",
"can-util",
"car hacking",
"ICSim",
"level 2 autonomous",
"OBD",
"python",
"self-driving"
] | There was a time not too long ago when hacking a car more often than not involved literal hacking. Sheet metal was cut, engine cylinders were bored, and crankshafts were machined to increase piston travel. It was all in the pursuit of milking the last ounce performance out of every drop of gasoline, along with a little personal expression in the form of paint and chrome.
While it’s still possible — and encouraged — to hack cars thus, the inclusion of engine control units and other systems to our rides has created an entirely different universe of car hacking options, which Amith Reddy distilled into
his very popular workshop at the 2020 Remoticon
. The secret sauce behind all the hacks you can accomplish in today’s drive-by-wire cars is the Controller Area Network (CAN), the network used to connect the array of sensors, actuators, and controllers that lie under the metal and plastic of modern cars.
The bulk of Amith’s workshop centered on how to receive and interpret CAN bus packets. The toolchain included
can-utils
, a collection of tools for inspecting and manipulating CAN packets, and
ICSim
, which simulates a generic car instrument cluster graphically. Using these, workshop participants were able to play with the virtual dashboard, open and close virtual doors, and observe the CAN packets responsible for it all as they fly across the network.
With the basics out of the way, the workshop moved on to real-world implementations of CANbus hacking, including tools to tap into the network via a car’s Onboard Diagnostics (OBD) port. There can be significant challenges here, including the dangers inherent when working with any large, powerful machine. The
workshop page
has all the details of what’s needed to get started, and the video of the workshop will take you the rest of the way safely. | 14 | 3 | [
{
"comment_id": "6302250",
"author": "New Hacker",
"timestamp": "2020-12-10T20:18:06",
"content": "I have a question related to a real car scenario.CAN communication in cars also utilise the feature of CRC, which provides message integrity.1. So what happens when we send a message without a CRC, i.e... | 1,760,373,258.588521 | ||
https://hackaday.com/2020/12/11/microstepping-a-pcb-motor/ | Microstepping A PCB Motor | Danie Conradie | [
"Tech Hacks"
] | [
"flexible PCB",
"microstepping",
"pcb motor",
"stepper driver",
"stepper motor"
] | 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
. | 24 | 11 | [
{
"comment_id": "6302543",
"author": "dudefromthenorth",
"timestamp": "2020-12-12T00:36:34",
"content": "The B-field over each of the coils cannot ever be uniform enough to step as finely as he wants….",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6302748",... | 1,760,373,258.701792 | ||
https://hackaday.com/2020/12/11/putting-the-finishing-touches-on-a-60w-laser/ | Putting The Finishing Touches On A 60W Laser | Tom Nardi | [
"Laser Hacks",
"Tool Hacks"
] | [
"K40",
"laser cutter",
"laser tube",
"modifications"
] | 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 a tool that costs this much wouldn’t at least offer such a thing as an option.
Drilling a hole for the ammeter.
[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. | 26 | 6 | [
{
"comment_id": "6302516",
"author": "Shrad",
"timestamp": "2020-12-11T21:16:12",
"content": "Any laser over Class IIIb with a service lid will not pass the easiest security certification if there is no safety interlock, for what I remember… this is not a feature, unless you are looking for free sur... | 1,760,373,259.204088 | ||
https://hackaday.com/2020/12/11/remoticon-video-breaking-encrypted-firmware-workshop/ | Remoticon Video: Breaking Encrypted Firmware Workshop | Mike Szczys | [
"cons",
"Hackaday Columns",
"how-to",
"Security Hacks"
] | [
"2020 Hackaday Remoticon",
"binaries",
"firmware binaries",
"reverse engineering",
"substitution",
"workshop"
] | If only you could get your hands on the code to fix the broken features on your beloved electronic widget. But wait, hardware hackers have the skills to write their own firmware… as long as we can get the compiled binary into a format the hardware needs.
Luckily, we have Uri Shaked to walk us through that process. This workshop from the 2020 Hackaday Remoticon
demonstrates how to decipher the encryption scheme used on the firmware binary
of a 3D printer. Along the way, we learn about the tools and techniques that are useful for many encrypted binary deciphering adventures.
The origin story of this workshop began when Uri decided to become a backer of a 3D printer on Kickstarter that had okay hardware but rubbish firmware. This was the second time he had fallen for it, but the first time around someone had saved his bacon by writing custom firmware to make the thing run well. This time the community needed help reverse engineering the new binary format before they could run custom code, so Uri jumped into action.
He’s using a CoLab notebook during the workshop to help everyone follow along as he runs a combination of Python and Linux shell commands. You can find the
links for everything on the workshop guide
, but to be honest there isn’t much in the way of secret sauce here. The true ingredient is ingenuity as a hex dumper to visualize the code, and Python to process it rounds out the bulk of the process.
Since the previous printer model’s firmware used a substitution cipher, Uri tries compressing the target binary. It seems that using robust encryption like AES 256 will make it difficult to compress efficiently. Since the bin file drops from 58 kb to 38 kb there’s a good chance it’s just a substitution.
Next he runs a histogram to plot repeated occurrence of characters and it becomes obvious right away which binary value stands in for 0x00, as that will be the most frequently used value (think leading zeros on 32-bit numbers), as well as 0xFF which usually pads out the ends of binaries. This is further confirmed by looking up the datasheet of the STM32 microcontroller to find that the vector reset table is always placed at the beginning of program memory. Since many values in the this table are known, and the placement of unknown values are specified, this turns out to be a huge key in getting the deciphering effort started.
The rest is an interesting game of finding obfuscated strings. Uri used
DotPeek
to decompile the .NET computer software that controls the printer and locates a few strings that software listens for on the serial connection. Since the printer will be sending these to the computer, they must exist somewhere in the binary.
Plot shows the distribution of repeated characters in the string “FIRMWARE_VERSION”. Used to visualise the pattern (not the actual values themselves) which is then searched for in the binary file.
This diagram shows
a function Uri wrote to visualize repetition within strings
. He uses it to judge if a string has enough repetition to serve as a uniquely identifiable pattern in the binary which will then reveal the substitution for each of those values. Here he hit the brick wall repeatedly before a eureka moment reveals that pairs of bytes in the binary are reversed. From there he rapidly begins to piece together a substitution table — using a custom hex dump view he wrote in Python to sanity check the process as he goes.
Due to a problem with the Zoom recording, the segment after the labs section of the workshop was not recorded, however everything you need is available in this video. Follow Uri’s lead, download the files he links, and see if you can find your own way through the rest of the substitutions.
This is a fantastic way to get better at this kind of deobfuscation task. We have both the binary itself, and Uri’s first hand recollection of the experience to guide us. The work is very much a jigsaw puzzle without a picture on the box, but as with most things in life, you get the hang of it as you do more of it. | 6 | 4 | [
{
"comment_id": "6302588",
"author": "Arik",
"timestamp": "2020-12-12T08:34:03",
"content": "Sweet work. Thank God manufacturers keep on inventing their own encryption schemes instead of using industry standards.",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "... | 1,760,373,259.135767 | ||
https://hackaday.com/2020/12/11/bare-metal-stm32-blinky-and-the-secret-of-delay-functions/ | Bare-Metal STM32: Blinky And The Secret Of Delay Functions | Maya Posch | [
"Hackaday Columns",
"Microcontrollers",
"Software Development"
] | [
"bare metal",
"nodate",
"stm32",
"timer"
] | One of the very first examples for an MCU or SoC usually involves the famous ‘
Blinky
‘ example, where an LED is pulsed on and off with a fixed delay. This is actually a lot more complicated than the ‘
Pushy
‘ example which we looked at
in the first installment of this series
. The reason for this is that there’s actually quite a story behind a simple call to
delay()
or its equivalent.
The reason for this is that there are many ways to implement a delay function on a microcontroller (MCU), each of which comes with their own advantages and disadvantages. On an STM32 MCU, we get to choose between essentially an active delay (
while
loop), one implemented using the SysTick timer and using one of the peripheral timers. In the latter two cases we also have to use interrupts.
In this article we’ll take a look at all three approaches, along with their advantages and disadvantages.
Recapping the Basics
In Arm MCU architectures, generally the same Cortex-M processor core is used within the same family of MCUs by a manufacturer such as ST Microelectronics (‘ST’). This core is connected via a variety of
AMBA
(Advanced Microcontroller Bus Architecture) buses, with AHB being the fast bus. AHB connects the core to all peripherals that need the low latency and speed, such as RAM, ROM, GPIO banks and display controllers.
STM32F0xx system architecture (RM 2.1).
Meanwhile the slower APB connects peripherals that are fine with less bandwidth and lower speeds, which includes the I2C, timers, USARTs and SPI peripherals. In the Pushy example, the processor core would constantly query the GPIO peripheral’s incoming data register (GPIO_IDR) and write into the outgoing data register (GPIO_ODR) depending on those input values.
Enter Blinky
In the case of the Blinky example, we remove the active polling of the GPIO_IDR that was used to read the button input, instead relying on the delay function that is added. Whenever we return from this blocking delay function, we toggle the GPIO_ODR bit, which causes the LED that is connected on that pin to be lit or not.
The code example as implemented using my
Nodate
framework thus becomes:
[gist
https://gist.github.com/MayaPosch/bcc02c9e35dd8f825cb0c6398089db9a
/]
This example defines a few presets for different boards, with here the ‘Blue Pill’ (STM32F103C8) version used. We won’t cover the
GPIO
module here again, as the used GPIO functions in this example were already explained in the first article in the series. Feel free to have a look at it if you need a refresher, though.
Our focus will be on the
Timer
module instead, the way its
delay()
function is implemented, as well as the two alternate approaches.
The Low-Tech, Active Delay
A completely serviceable, functional, and reasonably accurate delay feature can be implemented in a bare-metal environment using nothing more than a humble
while()
loop. This exploits the discrete nature of processor cycles in combination with knowing the current system clock. Essentially this means converting the desired delay to processor time and counting down (or up) to that interval.
Assume the MCU (SysClock) is clocked at 48 MHz. If we want to delay with microsecond resolution, we need to multiply the μs interval value with 48 to get the target number of clock cycles we wish to wait. Naturally, each iteration of the
while()
loop takes more than one clock cycle, so we then have to divide the number of clock cycles by the duration of a loop iteration. Say it takes 4 clock cycles for one loop iteration, we get:
int count = (usecs * 48) / 4;
while (int i = 0; i < count; ++i) {
count--;
}
Obviously, this is a rather easy way to implement a delay function, once one has calculated the appropriate parameters. As with many things in life, when something is this easy, it has to come with a whole list of gotchas. In the case of this delay function one doesn’t get disappointed in that regard.
First and foremost is its lack of accuracy. Even if we didn’t use integer values to calculate the appropriate clock cycle interval, there is still the unavoidable weakness in that this function fully runs on the (single) processor core. The moment a single interrupt occurs (e.g. from a timer, USART, I2C or GPIO peripheral), it will throw off the count by how many cycles it takes to process that interrupt and return to the main task execution.
The fact that this is an active delay, which fully occupies (in other words blocks) the processor further means that it does not work for a multitasking environment. In effect, this is the kind of delay function you really only wants to use as a quick-and-dirty throw-away function during testing or debugging.
Counting SysTicks
The Cortex-M core has a few standard peripherals as well that are integrated directly into this core. These are covered in the Programming Manual (PM) for each MCU family, e.g. for
STM32F0
. These so-called Core Peripherals include the SysTick Timer (STK, or SysTick), Nested Vectored Interrupt Controller (NVIC) and System Control Block (SCB). Of these, NVIC is as the name implies essential for registering and handling interrupts.
The SysTick timer is a fairly simple timer, which can essentially count down from the set value to zero. While this doesn’t sound amazing, it uses the processor clock, this means that it’ll not be affected by interrupts and other events that would interrupt the active delay timer which we looked at earlier.
As we saw in the Blinky example code, we first create an instance of the Timer class. This sets up a few items in the constructor of the Timer class:
[gist
https://gist.github.com/MayaPosch/62653ebd97f8c0e84d9c225844445cf4
/]
Most importantly, we set the value to countdown from. This uses the global SystemCoreClock value with the current system clock in Hertz, dividing it to create the equivalent value for 1 millisecond. This is written into STK_RVR (called LOAD in CMSIS).
We also pick the clock source to use with the SysTick peripheral, which here is ‘Processor clock’. Finally, we enable the generation of interrupts whenever the count reaches zero. With all of this configured, the
delay()
function can be used:
[gist
https://gist.github.com/MayaPosch/030d02d12e29a128fff4d8f5bd908b8c
/]
As mentioned, every time the SysTick timer reaches zero, it generates an interrupt. We reimplemented the interrupt handler
SysTick_Handler()
, so that on each call we can increment a global counter variable. The delay function itself starts the SysTick timer and waits for the global counter variable to reach the target value that was passed to it as a parameter. After completing this, the SysTick timer is disabled again and the function returns.
The advantages over an active delay loop should be fairly obvious: by using a hardware peripheral in the Cortex-M core, we are assured of good accuracy. With a change such as the use of the target interval as the STK_RVR value for example, we could further reduce any active waiting. SysTick can also be used for a central system timer, keeping track of uptime and intervals. Here one would quickly stray into the area of full-blown embedded operating systems, however.
Although somewhat more complicated than a simple while() loop, there’s no good reason to choose a blocking delay instead of the far superior SysTick method.
Timer Peripherals
While the SysTick timer is convenient in that it’s universally present in STM32 MCUs and exceedingly simple to use, this simplicity also comes with some disadvantages. Not the least of which is the fact that there is only a single SysTick peripheral. Fortunately, most STM32 MCUs come with a selection of additional timer peripherals that can also be used for adding delay functions, depending on one’s needs.
The
General-purpose timer cookbook for STM32 microcontrollers
(
AN4776
) document from ST gives an example of how to implement a basic delay loop in section 1.3.2, using the TIM6 peripheral:
[gist
https://gist.github.com/MayaPosch/32710d2aac8c46cb6327479b203f0b27
/]
Naturally, the fun thing with STM32 timer peripherals is that there are so many to choose from. Each of them falls within a certain complexity range, which scales roughly from ‘fairly basic’ to ‘everything and the kitchen sink’. The advanced timers are the ones you want to use for pulse-width modulation (PWM) and more complex tasks, leaving one with a few basic timers, the exact number of which depends on the MCU.
While we could count on the SysTick timer always being present, other timer peripherals are less predictable and require more effort to set them up. This makes them more suitable for specialized tasks, rather than implementing a delay loop. Which is not to say that one couldn’t do it, yet the benefits would have to be apparent.
Timing Out
With all of that said, I hope that this gives a clearer picture of delay loops on STM32 MCUs. These are hardly all the options either, with some enterprising people even
using the built-in debugging hardware
(e.g. Data Watchpoint Trigger, DWT) for timer functionality. Yet portability and ease of use should also be considerations.
At the end of this article, I would like to reiterate again that despite the common portrayal of the ‘Blinky’ example, there is actually a lot that goes into making it work. | 35 | 9 | [
{
"comment_id": "6302473",
"author": "Darko Kulić",
"timestamp": "2020-12-11T18:35:05",
"content": "This is a kind of article I would like to see more here. Thanks.",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6302475",
"author": "Greg A",
"timestamp... | 1,760,373,260.073964 | ||
https://hackaday.com/2020/12/11/hackaday-podcast-097-we-micromice-the-case-of-the-missing-drones-and-3d-prints-tested-for-rocketry-and-food-prep/ | Hackaday Podcast 097: We ♥ MicroMice, The Case Of The Missing Drones, And 3D Prints Tested For Rocketry And Food Prep | Mike Szczys | [
"Hackaday Columns",
"Podcasts"
] | [
"Hackaday Podcast"
] | Hackaday editors Mike Szczys and Elliot Williams round up the latest hardware hacks. This week we check out the latest dead-simple automation — a wire cutting stripping robot that uses standard bypass strippers. Put on your rocket scientist hat and watch what happens in a 3D-printed rocket combustion chamber. Really small robots are so easy to love, this micromouse is the size of a coin. And whatever happened to those drone sightings at airports? We talk about all that, and round up the episode with Hyperloop, and Xiaomi thermometers.
Take a look at the links below if you want to follow along, and as always, tell us what you think about this episode in the comments!
Direct download
(~60 MB)
Places to follow Hackaday podcasts:
Google Podcasts
iTunes
Spotify
Stitcher
RSS
Episode 097 Show Notes:
New This Week:
Mike badgered me into taking this photo.
Elliot’s adding axes to his hot-wire cutter, waiting for parts is lousy.
Interesting Hacks of the Week:
An Epic Quest For A Motorized Volume Knob
This Automated Wire Prep Machine Cuts And Strips The Wire
SLA 3D Printed Vortex Cooled Rocket Engine
Food Safe Printing Techniques
These Micro Mice Have Macro Control
MicroMouse KERISE v3
The Gatwick Drone: Finally Someone Who Isn’t Us Asks Whether It Ever Really Existed
Quick Hacks:
Mike’s Picks:
No-Battery Pressure Sensors For Bike Tyres
Tiny Chain-Link Fence Made With Hand-Cranked Brilliance
Flipbook Automation Saves Your Thumb
Elliot’s Picks:
Cassette Synth Plays With Speed Control
Slim RGB Matrix Puts LEDs Inside The PCB
ARM And X86 Team Up In No Compromise Cyberdeck
Can’t-Miss Articles:
Hyperloop: Fast, But At What Cost?
Exploring Custom Firmware On Xiaomi Thermometers | 3 | 2 | [
{
"comment_id": "6302483",
"author": "CMH62",
"timestamp": "2020-12-11T19:20:22",
"content": "I really enjoyed the article this week on the Xiaomi thermometers. That’s right at the core of what I consider to be Hackaday and a key reason I read the site everyday. Thanks for the job you two do.",
... | 1,760,373,259.751255 | ||
https://hackaday.com/2020/12/11/still-got-film-to-scan-this-lego-and-raspberry-pi-scanner-is-for-you/ | Still Got Film To Scan? This Lego And Raspberry Pi Scanner Is For You | Jenny List | [
"digital cameras hacks",
"Machine Learning",
"Raspberry Pi"
] | [
"film scanner",
"Google Coral",
"lego",
"raspberry pi"
] | 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
. | 9 | 7 | [
{
"comment_id": "6302450",
"author": "ChrE",
"timestamp": "2020-12-11T16:05:35",
"content": "Oh there’s plenty of film left to scan. For my parents’ 30th anniversary, I found and had professionally scanned the negatives from their wedding album, and got reprints made. They came out WAY better and sh... | 1,760,373,259.916696 | ||
https://hackaday.com/2020/12/11/this-week-in-security-vmware-microsoft-teams-python-fuzzing-and-more/ | This Week In Security: VMWare, Microsoft Teams, Python Fuzzing, And More | Jonathan Bennett | [
"Hackaday Columns",
"News",
"Security Hacks"
] | [
"fuzzing",
"This Week in Security",
"tls",
"Trickbot"
] | 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. | 9 | 4 | [
{
"comment_id": "6302449",
"author": "jpa",
"timestamp": "2020-12-11T16:01:00",
"content": "“Microsoft replied that they don’t issue CVEs for products that get updated automatically without user interaction.”For online webapps not assigning a CVE would be in line with MITRE rules (https://cve.mitre.... | 1,760,373,259.801654 | ||
https://hackaday.com/2020/12/09/this-automated-wire-prep-machine-cuts-and-strips-the-wire/ | This Automated Wire Prep Machine Cuts And Strips The Wire | Dan Maloney | [
"Tool Hacks"
] | [
"arduino",
"cut",
"stepper",
"strip",
"stripper",
"wire"
] | We’ve seen a fair number of automated wire cutting builds before, and with good reason: cutting lots of wires by hand is repetitive and carries the risk of injury. What’s common to all these automated wire cutters is a comment asking, “Yeah, but can you make it strip too?” As it turns out, yes you can.
The key to making
this automated wire cutter and stripper
is [Mr Innovative]’s choice of tooling, and accepting a simple compromise. (Video, embedded below.) Using just about the simplest wire strippers around — the kind with a diamond-shaped opening that adjusts to different wire gauges by how far the jaws are closed — makes it so that the tool can both cut and strip, and adapt to different wire sizes. The wire is fed from a spool to a custom attachment sitting atop a stepper motor, which looks very much like an extruder from a 3D-printer. The wire is fed through a stiff plastic tube into the jaws of the cutter. Choosing between cutting and stripping is a matter of aiming the wire for different areas on the cutter’s jaws, which is done with a hobby servo that bends the guide tube. The throw of the cutter is controlled by a stepper motor — partial closure nicks the insulation, while a full stroke cuts the wire off. The video below shows the build and the finished product in action.
Yes, the insulation bits at the end still need to be pinched off, but it’s a lot better than doing the whole job yourself. [Mr Innovative] has a knack for automating tedious manual tasks like this. Check out his
label dispenser
,
a motor rotor maker
, and
thread bobbin winder
. | 23 | 10 | [
{
"comment_id": "6301647",
"author": "Vlad",
"timestamp": "2020-12-09T09:33:02",
"content": "It´s a stripper that does not strip. Like a COVID lap-dancer with hazmat.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6301663",
"author": "gkka",
... | 1,760,373,259.7025 | ||
https://hackaday.com/2020/12/08/printed-circuits-1940s-style/ | Printed Circuits, 1940s Style | Chris Lott | [
"classic hacks"
] | [
"antique radio",
"automated manufacturing",
"history",
"pcb",
"Sargrove"
] | A
presentation
this month by the
Antique Wireless Museum
brought British engineer and inventor
John Sargrove
(1906-1974) to our attention. If you’ve ever peeked inside old electronics from days gone by, you’ve no doubt seen
point-to-point wiring
and
turret board construction
. In the 60s and 70s these techniques eventually made way for printed circuit boards which we still use today. But Mr Sargrove was way ahead of his time, having already invented a process in the 1930s to print circuits, not just boards, onto
Bakelite
. After being interrupted by the war, he formed a company Electronic Circuit Making Equipment (ECME) and was building
broadcast radio receivers
on an impressive automatic production line.
Mr. Sargrove’s passion was making radios affordable for everyone. But to achieve this goal, he had to make large advances manufacturing technology. His technique of embedding not only circuit traces, but basic circuit elements like resistors, capacitors, and inductors directly into the substrate foresaw techniques being applied decades later in integrated circuit design. He also developed a compact vacuum tube which could be used in all circuits of a radio, called an “
All-stage Valve
“. Equally important was his futuristic automatic factory, which significantly reduced the number of factory workers needed to make radios from 1500 to 50. Having completed the radio design, he was also developing a television receiver using the same concepts. Unfortunately, ECME was forced into liquidation when a large order from India was cancelled upon declaration of independence in 1947.
You really must watch the video below. There are many bits and pieces of modern factory automation which we still use today, yet their implementation using 1940s techniques and technology is fascinating. Further reading links after the video. Thanks to [Mark Erdle] for the tip.
Article in Modern Mechanix, Apr 1948
Obituary, The Radio and Electronic Engineer Vol 43, No 3
QSL.net article on Sargrove and Eisler | 35 | 15 | [
{
"comment_id": "6301615",
"author": "Paul Cohen",
"timestamp": "2020-12-09T06:30:09",
"content": "Is there such a radio survived somewhere?Is it still operating and can be seen?",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6301734",
"author": "Dud... | 1,760,373,260.292073 | ||
https://hackaday.com/2020/12/08/roll-your-own-tracking/ | Roll Your Own Tracking | Matthew Carlson | [
"Microcontrollers",
"Wireless Hacks"
] | [
"ESP8266",
"IoT",
"tracking",
"wifi",
"wireless"
] | The smartphone is perhaps the signature device of our modern lives. For most of the population it is never more than an arm’s length away, it’s on your person more than any other device in your life. Smartphones are packed with all sorts of radios and ways to communicate wireless. [Amine Mansouri]
built an ESP8266 based tracking device that takes advantage of this
.
Most WiFi-enabled devices will send out “probe requests” frames trying to search for the SSIDs they were connected to. These packets contain the device MAC address as well as the SSIDs you’ve connected to. Using about 12 components, [Amine] laid out a small board in Eagle. By putting the ESP8266 in monitor mode, the probe frames can be logged and uploaded. The code can be updated OTA making it easy to service while in the field.
With permission from his local library, eight repeater boards were scattered throughout the building to forward the probe packets to where the tracker could pick them up. A simple web interface was built that allows the library to figure out how many people are in the library and how often they frequent the premises.
While an awesome project with
open-source code on Github
, it is important to stress how important is it to get permission to do this kind of tracking. While some phones implement MAC randomization, there are still many out in the wild that don’t. While this is similar to
another project that listens to radio signals to determine the coming and going of ships and planes
, tracking people with this sort of granularity is in a different category altogether.
Thanks [Amine] for sending this one in! | 35 | 10 | [
{
"comment_id": "6301578",
"author": "Thrasher",
"timestamp": "2020-12-09T03:50:41",
"content": "Counting smartphones counting people.",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6301580",
"author": "Cyna",
"timestamp": "2020-12-09T03:59:24",
"... | 1,760,373,259.873088 | ||
https://hackaday.com/2020/12/08/home-crafting-a-motorcycle-throttle-hold/ | Home-Crafting A Motorcycle Throttle Hold | Lewin Day | [
"Transportation Hacks"
] | [
"motorbike",
"motorcycle",
"throttle"
] | Cruise control is a common feature on automobiles, though less so in the motorcycle market. Given that continual throttle application on long rides can be a real pain in the wrist, many riders long for such a convenience. As a cheat solution, bolt-on locks that hold the throttle at a set position are available, though quality varies and generally they need to be activated by the throttle hand anyway. [Nixie] wanted a solution that would leave the right hand entirely free,
and held, rather than locked, the throttle.
The device [Nixie] came up with is essentially a brake that fits inside the throttle handle and holds it in position. This is achieved with a mechanism that presses a pair of small brake shoes into the inside of the throttle, holding it from rotating back to neutral when the rider lets go. The brake is activated by a control on the left handlebar via a Bowden cable, allowing [Nixie] to activate the throttle hold on the highway and use the right hand to check pockets or simply rest.
It’s a tidy build, and [Nixie] does a great job of explaining the various design choices and the intricacies of the Bowden cable actuated mechanism. It’s anything but a one-size-fits-all build, but other enterprising machinists could certainly duplicate the design for other motorcycles without too many problems.
For those interested in more traditional cruise control,
we’ve featured a teardown of a simplistic 90s Jeep system before
. Video after the break. | 38 | 11 | [
{
"comment_id": "6301531",
"author": "Cricri",
"timestamp": "2020-12-09T00:22:34",
"content": ">This is achieved with a mechanism that presses a pair of small brake shoes into the inside of the throttle, holding it from rotating back to neutral when the rider lets go.What could possibly go wrong?",
... | 1,760,373,259.994517 | ||
https://hackaday.com/2020/12/08/devterm-beats-cyberdeck-builders-to-the-punch/ | DevTerm Beats Cyberdeck Builders To The Punch | Tom Nardi | [
"ARM",
"Cyberdecks",
"Linux Hacks"
] | [
"arm",
"Compute Module 3",
"cyberdeck",
"modular electronics",
"portable computer",
"retro computer"
] | What makes a cyberdeck? Looking as though it came from an alternate reality version of the 1980s is a good start, but certainly isn’t required. If you’re really trying to adhere to the cyberpunk ethos, any good deck should be modular enough that it can be easily repaired and upgraded over time. In fact, if it’s not in a constant state of evolution and flux, you’ve probably done something wrong. If you can hit those goals
and
make it look retro-futuristic at the same time, even better.
Which is why
the Clockwork DevTerm is such an interesting device
. It ticks off nearly every box that the custom cyberdeck builds we’ve covered over the last couple years have, while at the same time being approachable enough for a more mainstream audience. You won’t need a 3D printer, soldering iron, or hot glue gun to build your own DevTerm. Of course if you
do
have those tools and the skills to put them to work, then this might be the ideal platform to build on.
With a 65% QWERTY keyboard and widescreen display, the DevTerm looks a lot like early portable computers such as the TRS-80 Model 100. But unlike the machines it draws inspiration from, the display is a 6.8 inch 1280 x 480 IPS panel, and there’s no pokey Intel 8085 chip inside. The $220 USD base model is powered by the Raspberry Pi Compute Module 3, and if you need a little more punch, there are a few higher priced options that slot in a more powerful custom module.
Like the Waveshare Pi CM laptop we recently looked at
, there’s sadly no support for the newer CM4; but at least the DevTerm is modular enough that it doesn’t seem out of the question that Clockwork could release a new mainboard down the line. Or perhaps somebody in the community will even do it for them.
Speaking of which, the board in the DevTerm has been designed in two pieces so that “EXT Module” side can be swapped out with custom hardware without compromising the core functionality of the system. The stock board comes with extra USB ports, a micro USB UART port for debugging, a CSI camera connector, and an interface for an included thermal printer that slots into a bay on the rear of the computer. Clockwork says they hope the community really runs wild with their own EXT boards, especially since the schematics and relevant design files for the entire system are all going to be put on GitHub and released under the GPL v3.
They say that anything that sounds too good to be true probably is, and if we’re honest, we’re getting a little of that from the DevTerm. An (CPU BLOBs aside!) open hardware portable Linux computer with this kind of modularity is basically a hacker’s dream come true, and thus far
the only way to get one was to build it yourself
. It’s hard to believe that Clockwork will be able to put something like this out for less than the cost of a cheap laptop without cutting some serious corners somewhere, but we’d absolutely love to be proven wrong when it’s released next year. | 45 | 14 | [
{
"comment_id": "6301487",
"author": "Inhibit",
"timestamp": "2020-12-08T21:16:07",
"content": "Hmm. Yea. While the price point doesn’t scream impossible I’d be a bit more sure if that didn’t look like an entire BOM of bespoke parts.Although I’ve heard of their Clockwork Pi product out in the wild. ... | 1,760,373,260.219728 | ||
https://hackaday.com/2020/12/08/remoticon-video-making-microphones-and-finding-sound/ | Remoticon Video: Making Microphones And Finding Sound | Mike Szczys | [
"cons",
"how-to"
] | [
"2020 Hackaday Remoticon",
"found sound",
"microphone",
"piezo",
"piezo disk",
"workshop"
] | A yogurt lid and embroidery hoop are key components in building this microphone. It’s a super low tech, entry-level project to get into “found sound” and exactly what is needed to start hacking around in the audio world. This workshop presented by
Helen Leigh and Robyn Hails shows you how to build a simple microphone
and use it as the electronic gateway to all kinds of audio shenanigans.
Key to this build are the piezo element and an amp to process the signals it generates. All other materials are common around most households, but put them together as shown in this live hands-on seminar from the 2020 Hackaday Remoticon, and I think you’ll surprise yourself with how good the thing sounds!
Microphones pick up the tiny vibrations of audio waves moving through the air. The trick is to pick up the right vibrations and avoid the wrong ones, which is the guiding principle in this design. First, a plastic diaphragm cut from the lid of a yogurt container serves as the anchor point for the piezo element, serving as a sounding board to pick up those tiny audio vibrations that the piezo will turn into an electric signal.
This assembly is isolated from traveling through the mounting mechanism for the mic by suspending it inside of a wooden embroidery hoop using document binder clips (in a most excellent gold color) and elastic cord. There is some element of danger here as the unbalanced microphone signal has the potential to blow out your speakers so be sure to set the gain all the way down and proceed with caution as you crank up the volume.
Built by workshop presenters
Built by attendee
Built by attendee
A number of the workshop attendees posted photos of their complete mics in the public chat which you’ll find on
the workshop project page
. If you want to build one of these yourself
you can find the materials list here
.
While highly sensitive mics are in any number of electronics at our fingertips these days, boiling this concept down to its most basic feels much cooler than simply opening up a recording app on your phone. Once you’ve gotten your feet wet with piezo input, take a look around and start adding them to all kinds of eclectic objects so they can be sound sources in your next audio creation. | 14 | 5 | [
{
"comment_id": "6301482",
"author": "Steven-X",
"timestamp": "2020-12-08T21:06:12",
"content": "Near project. I have a pile of extra large piezos that I was wanting to use, maybe one will find it’s life purpose as a mic (another two might become a pair of headphones)A number of years ago I was expe... | 1,760,373,260.131472 | ||
https://hackaday.com/2020/12/08/space-is-radioactive-dealing-with-cosmic-rays/ | Space Is Radioactive: Dealing With Cosmic Rays | Moritz v. Sivers | [
"Featured",
"Science",
"Slider",
"Space"
] | [
"cosmic rays",
"iss",
"solar flare",
"space radiation"
] | Outer space is not exactly a friendly environment, which is why we go through great lengths before we boost people up there. Once you get a few hundred kilometers away from our beloved rocky planet things get uncomfortable due to the lack of oxygen, extreme cold, and high doses of radiation.
Especially the latter poses a great challenge for long-term space travel, and so people are working on various concepts to protect astronauts’ DNA from being smashed by cosmic rays. This has become ever more salient as NASA contemplates future manned missions to the Moon and Mars. So let’s learn more about the dangers posed by galactic cosmic rays and solar flares.
Radiation from Space
When German Jesuit priest and physicist Theodor Wulf climbed the Eiffel Tower in 1910 with an electrometer he wanted to show that natural sources of ionizing radiation are originating from the ground. And while readings on top of the tower were lower than the ground level, they were still much higher than would be expected if the ground were the only source. A few years later, Victor Hess undertook several risky balloon flights up to altitudes of 5.3 km to systematically measure the radiation level by observing the discharge rate of an electroscope. His experiments showed that radiation levels increase above ~1 km, and he correctly concluded that there must be some source of radiation penetrating the atmosphere from outer space.
The cosmic rays that rain down on Earth are predominantly protons (~90%), helium nuclei (~9%), and electrons (~1%). In addition, there is a small fraction of heavier nuclei and a tiny whiff of antimatter. These particles are blasted to us from the Sun and other galactic and extragalactic natural particle accelerators like supernovae or black holes.
How Earth Keeps Us Safe
Van Allen Belt and location of South Atlantic Anomaly
Credit:
Marko Markovic
, public domain
Luckily for us, the Earth’s magnetic field deflects many of the charged particles so that they never hit the atmosphere. Some of them are captured in two donut-shaped rings around the Earth, the Van Allen Belts. In addition, the atmosphere also does a good job of protecting us. Primary cosmic rays hitting the atoms in our atmosphere produce a shower of secondary particles with much lower energies so that most of them will not reach the ground.
The average radiation exposure here on Earth is about 3
mSv per year. Depending on your altitude, about 0.39 mSv (13%) is contributed by cosmic radiation. Flying in an airplane at 12 km altitude increases your radiation exposure about 10x compared to sea-level. Things are even worse if your flight route is near the geomagnetic poles where charged particles are concentrated. If you are interested in the radiation dose you will receive on your next flight, check out NASA’s
NAIRAS
webpage. It provides a global map of radiation dose rates for different altitudes that are produced in near real-time from measurements of solar activity and cosmic rays.
Doses on the ISS, the Moon, and Mars
Comparison of radiation doses. Note logarithmic scale.
Credit:
ASA/JPL-Caltech/SwRI
, Public Domain
For a crew member of the ISS, the average radiation dose is about 72 mSv for a six-month stay during solar maximum: it is about 50 times higher than on Earth. Because the contribution from solar particles varies with the
11-year solar cycle
, one might think that the radiation dose is lower during solar minimum. But in fact, the dose is about twice as high as during solar maximum.
This is because the dominant source of radiation on the ISS is galactic cosmic rays (GCR), which are deflected by the Sun’s magnetic field. GCR intensity is highest during solar minimum when the Sun’s magnetic field is weakest. Even a big solar particle event (SPE) like a solar flare or
coronal mass ejection
cannot hurt ISS astronauts much but instead sweeps away other charged particles thereby reducing the GCR flux for weeks. This effect is known as the
Forbush decrease
.
Another big contribution to the radiation exposure aboard the ISS comes from protons trapped in the Van Allen belt. The exposure is largest when the ISS crosses the so-called South Atlantic Anomaly (SAA) where the radiation belt comes closer to Earth’s surface. Most of the time, the ISS orbits comfortably inside the Van Allen belt, but during the 5% of the mission time that the ISS is spends in the SAA, it can be responsible for more than 50% of the total absorbed radiation dose.
The Moon, on the other hand, is exposed to all kinds of cosmic rays since it is located much further away and has neither a magnetic field nor an atmosphere. Here SPEs like the big solar storm that occurred in August 1972, shortly in between the Apollo 16 and Apollo 17 lunar missions, can be life-threatening events for astronauts. Recently, the Lunar Lander Neutrons and Dosimetry (LND) experiment aboard China’s Chang’E 4 lander has
measured the radiation exposure on the lunar surface
. With about 500 mSv/year the radiation dose is nearly 200 times higher than on Earth.
Plans for manned missions to Mars are already underway and radiation exposure is one of the main concerns. Estimations of the radiation dose for a trip to Mars are based on
measurements of the Radiation Assessment Detector (RAD) piggybacking on the Curiosity rover
. During a 360-day round trip, an astronaut would receive a dose of about 660 mSv. Assuming that the crew would spend 18 months on the surface while they wait for the planets to realign, they will be exposed to an additional 330 mSv. So the total exposure for an astronaut going to Mars and back will be around 1,000 mSv. This is equal to the exposure limit for NASA astronauts during their entire career, and corresponds to a
5.5% risk of death due to radiation-induced cancer
. Therefore, although there is certainly a severe health risk, radiation exposure is not a showstopper for a mission to Mars.
Protecting Space Travelers
The radiation protection plan for the Orion spacecraft includes building a shelter from stowage bags during an SEP event.
Credit:
NASA
Astronauts aboard the ISS are partially protected against radiation by the station’s aluminum hull. Materials with low atomic number provide the most effective protection against space radiation including secondary particles like neutrons. Such lightweight materials are also cheaper to bring into space. The ISS has equipped their crew quarters with polyethylene bricks that reduce the radiation dose by 20%.
If we ever construct settlements on the Moon, they will probably be buried beneath lunar soil to be shielded from SPEs and other cosmic rays. On the downside, this would also increase the exposure to secondary neutrons, as measurements of the Apollo 17 Lunar Neutron Probe Experiment have shown.
NASA’s Orion spacecraft is planning to bring people to the Moon in 2024 and eventually to Mars. Since the additional mass for dedicated shielding would simply be too expensive their radiation protection plans include the possibility to build a shelter from onboard supplies including food and water in case of an SPE.
Let’s not forget that space radiation is not only dangerous to humans but also to electronic equipment. High-energy particle interactions can easily damage critical electronic systems on a spacecraft and are causing total or partial mission loss for between one and two satellites per year. Extreme SPEs can even influence equipment on Earth like the 1972 solar storm which is said to have caused the accidental detonation of two dozen US sea mines in Vietnam.
For the future of space travel, more advanced active shielding concepts are the topic of ongoing research. These include powerful magnetic or electrostatic fields and plasma “bubbles” surrounding a spacecraft to deflect charged particles. Of course, radiation protection is only one of the many challenges posed by long-term space travel but let’s hope we will find ways to keep our astronauts safe and healthy. | 44 | 12 | [
{
"comment_id": "6301434",
"author": "mjrippe",
"timestamp": "2020-12-08T18:25:38",
"content": "Solar flare? Build a pillow fort!",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6301438",
"author": "Paula",
"timestamp": "2020-12-08T18:46:20",
"cont... | 1,760,373,260.49127 | ||
https://hackaday.com/2020/12/08/a-portable-serial-terminal-that-should-be-from-the-1970s/ | A Portable Serial Terminal That Should Be From The 1970s | Jenny List | [
"Peripherals Hacks",
"Retrocomputing"
] | [
"6809",
"serial",
"terminal"
] | The humble standalone serial terminal might be long gone from the collective computing experience, but in the ghostly form of a software virtual terminal and a serial converter it remains the most basic fall-back and essential tool of the computer hardware hacker. [Mitsuru Yamada] has created the product that should have been made in the serial terminal’s heyday,
a standalone handheld terminal using a 6809 microprocessor and vintage HP dot matrix LEDs
. In a die-cast box with full push-button keyboard it’s entirely ready to roll up to a DB-25 wall socket and log into the PDP/11 in the basement.
Using today’s parts we might achieve the same feat with a single-chip microcontroller and a small LCD or OLED panel, but with an older microcomputer there is more system-building required. The 6809 is a wise choice from the 1970s arsenal because it has some on-board RAM, thus there’s no need for a RAM chip. Thus the whole thing is achieved with only a 2716 EPROM for the software, a 6850 UART with MAX232 driver for the serial port, and a few 74 chips for glue logic, chip selects, and I/O ports to handle keyboard and display. There’s no battery in the case, but no doubt that could be easily accommodated. Also there’s not much information on the keyboard itself, but in the video below we catch a glimpse of its wiring as the box is opened.
The value in a terminal using vintage parts lies not only in
because you can
, but also in something that can’t easily be had with a modern microcontroller. These parts come from a time when a computer system had to be assembled as a series of peripherals round the microprocessor because it had few onboard, leading to a far more in-depth understanding of a computer system. It’s not that a 6809 is a sensible choice in 2020, more that it’s an
interesting
one.
By comparison,
here’s a terminal using technology from today
. | 38 | 14 | [
{
"comment_id": "6301414",
"author": "Chris Snyder",
"timestamp": "2020-12-08T16:37:55",
"content": "I wish I had something like this 20 years ago for working on pbx’s rather than having to lug around a wise 60 terminal.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comm... | 1,760,373,260.564512 | ||
https://hackaday.com/2020/12/08/exploring-custom-firmware-on-xiaomi-thermometers/ | Exploring Custom Firmware On Xiaomi Thermometers | Tom Nardi | [
"Hackaday Columns",
"how-to",
"Parts",
"Slider"
] | [
"bluetooth",
"bluetooth low energy",
"custom firmware",
"environmental monitoring",
"environmental sensor",
"IoT",
"xiaomi"
] | If we’ve learned anything over the years, it’s that hackers love to know what the temperature is. Seriously. A stroll through the archives here at Hackaday uncovers an overwhelming number of bespoke gadgets for recording, displaying, and transmitting the current conditions. From outdoor weather stations to an ESP8266 with a DHT11 soldered on, there’s no shortage of prior art should you want to start collecting your own environmental data.
Now obviously we’re big fans of DIY it here, that’s sort of the point of the whole website. But there’s no denying that it can be hard to compete with the economies of scale, especially when dealing with imported goods. Even the most experienced hardware hacker would have trouble building something like the Xiaomi LYWSD03MMC. For as little as $4 USD each, you’ve got a slick energy efficient sensor with an integrated LCD that broadcasts the current temperature and humidity over Bluetooth Low Energy.
You could probably build your own…but why?
It’s pretty much the ideal platform for setting up a whole-house environmental monitoring system except for one detail: it’s designed to work as part of Xiaomi’s home automation system, and not necessarily the hacked-together setups that folks like us have going on at home. But that was before Aaron Christophel got on the case.
We first brought news of his
ambitious project to create an open source firmware for these low-cost sensors
last month, and unsurprisingly it generated quite a bit of interest. After all, folks taking existing pieces of hardware, making them better, and sharing how they did it with the world is a core tenet of this community.
Believing that such a well crafted projected deserved a second look, and frankly because I wanted to start monitoring the conditions in my own home on the cheap, I decided to order a pack of Xiaomi thermometers and dive in.
Firmware Installation
Certainly one of the most appealing aspects of Aaron’s “ATC” firmware is how easy it is to install. You’d expect something like this would require cracking the case and attaching a USB to UART adapter, and while you actually
can
go that route if you need to, 99% of users will be
using the extremely clever “Web Bluetooth” flashing tool
.
In theory you should be able to install the ATC firmware from any computer running a modern enough web browser, but your mileage may vary with such a cutting-edge feature. My Linux desktop couldn’t connect to the thermometers at all, and trying it on a Chromebook only worked occasionally. Your best bet is probably going to be a smartphone or tablet, and I had no problem flashing several of the thermometers using my Pixel 4a.
All told, the flashing process takes a little under a minute to complete. After you pull the tab on the back of the thermometer, you tap “Connect” on the flasher and wait for it to pop up on the list of local Bluetooth devices. After connecting you need to hit the “Activate” button, which apparently establishes the secure connection required by the original firmware before it will allow for an over the air (OTA) upgrade.
Once the activation process is complete, you select a firmware binary, tap “Start Flashing”, and wait as the progress indicator ticks up towards 100%. This takes around 30 seconds to finish, and afterwards the thermometer should immediately reboot into the new firmware. If it doesn’t wake up after the flashing process, Aaron says you can just pull the battery and it should sort itself out. I’ve gone through this process several times now without ever needing to pull a battery though, so presumably it’s a fairly uncommon problem.
Should you ever need to, the same process can be used to put the stock firmware back on the device. Aaron doesn’t have a stock firmware image in the GitHub repository (likely to avoid a copyright claim) but in the documentation he does tell you how you can extract a copy of it from an official update file.
Now, the more security minded reader may be wondering it this means some militant nerd can go around bricking people’s Xiaomi thermometers. Unfortunately, it does. This tool will let anyone within Bluetooth range flash whatever they want to the Xiaomi LYWSD03MMC, regardless of whether or not it has a custom firmware installed. That said, there’s already been mention of adding some kind of authentication mechanism to the ATC firmware to defend against such attacks; making it notably more secure than the stock firmware.
Getting Comfortable
The web flashing tool doesn’t just install the ATC firmware, it also provides an easy to use interface for configuring it. After connecting to the device, you just scroll down a bit and just tap on the various options to enable or disable them.
Turning off the weird ASCII-art smiley face was the first thing I did, and being an American heathen, I also changed the display to Fahrenheit. The fact that you can enter an offset values for the temperature and humidity is handy, though it might become unnecessary in the future as Aaron says a more robust calibration routine is on the TODO list.
Showing the battery level on the screen is an interesting feature that’s enabled by default, but personally I turned it off. The problem is that the battery percentage and relative humidity have to share the smaller set of digits on the bottom right side of the LCD. They switch back and forth every five seconds or so, which in practice seems just fast enough that it’s sometimes confusing as to which one you’re looking at. Plus when the CR2032 battery inside is supposed to last up to a year, do I really need to see the battery level so often?
I was a bit confused by “Advertising Interval” at first. I assumed this would be how often the thermometer sends out a BLE packet, but in practice, it sends them out every few seconds regardless of what you change this setting to. What this setting
actually
changes is how often the temperature data that’s being broadcast gets updated. The default is one minute, so you should expect to get 20 or so packets that will contain the same temperature and humidity values before they get refreshed. Setting the update interval to 10 seconds would give you more granular data, but presumably at the cost of battery life.
Custom Builds
While Aaron doesn’t go into too much detail on the project page, it’s fairly easy to compile your own firmware for the thermometer that can then be flashed with the web tool. On Linux, all I had to do was extract the Xiaomi Telink TLSR825X tarball and add the directory to my $PATH environment variable. From there I could build the ATC firmware and start poking around at the code.
Custom names are just a few lines of code away.
If you’re into low-level C programming, there are a number of Issues in the GitHub repository that you could probably help out with. It sounds like the major one right now is establishing persistent flash storage, which would pave the way for being able to retain configuration across battery changes and more advanced features like local temperature logging.
For my own purposes, it was easy enough to find the part of the code that changes the Bluetooth device name. If you’re going to be dotting these all over the house, seeing something like “ATC_BEDROOM” will certainly be more helpful than the default naming scheme which uses the last characters of the MAC address.
Pulling in the Data
Now to be clear, you don’t
need
to install Aaron’s firmware to use the data from these thermometers in your own projects.
There’s at least one tool
that allows you to pull the temperature, humidity, and battery level from the sensors out of the box, and
they’re also supported in ESPHome
. But the problem with the stock firmware is that you need to actually connect to each sensor to read its data, which is a slow and energy intensive process. One of the main improvements in Aaron’s firmware is that the data is constantly being pushed out in the clear as a BLE advertisement; meaning any nearby device can sniff the values right out of the air without establishing a connection or pairing.
To that end, there are a few packages worth taking a look at. At the time of this writing there’s a pull request to
add support for ATC firmware to aioblescan
, a simple Python 3 tool that will dump data from the BLE packets to the terminal. A little scripting would allow you to easily parse the output from aioblescan and shuffle the information around however you see fit.
I’ve also
had good luck with py-bluetooth-utils
, a library designed for working with BLE advertisements. Based on some examples included with the project, I’ve come up with this minimal script which should get you started:
#!/usr/bin/env python3
import sys
from datetime import datetime
import bluetooth._bluetooth as bluez
from bluetooth_utils import (toggle_device, enable_le_scan,
parse_le_advertising_events,
disable_le_scan, raw_packet_to_str)
# Use 0 for hci0
dev_id = 0
toggle_device(dev_id, True)
try:
sock = bluez.hci_open_dev(dev_id)
except:
print("Cannot open bluetooth device %i" % dev_id)
raise
# Set filter to "True" to see only one packet per device
enable_le_scan(sock, filter_duplicates=False)
try:
def le_advertise_packet_handler(mac, adv_type, data, rssi):
data_str = raw_packet_to_str(data)
# Check for ATC preamble
if data_str[6:10] == '1a18':
temp = int(data_str[22:26], 16) / 10
hum = int(data_str[26:28], 16)
batt = int(data_str[28:30], 16)
print("%s - Device: %s Temp: %sc Humidity: %s%% Batt: %s%%" % \
(datetime.now().strftime("%Y-%m-%d %H:%M:%S"), mac, temp, hum, batt))
# Called on new LE packet
parse_le_advertising_events(sock,
handler=le_advertise_packet_handler,
debug=False)
# Scan until Ctrl-C
except KeyboardInterrupt:
disable_le_scan(sock)
Just Do It
If you can’t tell, I
really
like Aaron Christophel’s custom firmware for the Xiaomi LYWSD03MMC. As far as I can tell, there’s absolutely no reason not to install it if you’ve already got some of these thermometers laying around. In its current state it gives you greater control over the hardware and what you can do with it, and the features currently in the planning stages promise to take things even farther. Being able to locally log temperature data on the thermometer and download it over BLE at a later date is definitely something to keep an eye out for.
For as cheap as these little thermometers are, I’d highly recommend adding a few to your next parts order. Even if you don’t have an idea in mind for them yet, I wouldn’t be surprised if something comes to you after spending an afternoon hacking their firmware. | 55 | 28 | [
{
"comment_id": "6301374",
"author": "Alphatek",
"timestamp": "2020-12-08T15:04:53",
"content": "Waiting for mine to arrive after reading the previous article. I’m hoping to be able to find some spare gpio on the board so I can try to use them as wireless thermostats.",
"parent_id": null,
"d... | 1,760,373,260.669003 | ||
https://hackaday.com/2020/12/08/sla-3d-printed-vortex-cooled-rocket-engine/ | SLA 3D Printed Vortex Cooled Rocket Engine | Danie Conradie | [
"Engine Hacks",
"Space"
] | [
"3d printing",
"liquid fuel rocket engine",
"rocket",
"SLA printer"
] | 3D printing is an incredible tool for prototyping and development, but the properties of the materials can be a limiting factor for functional parts. [Sam Rogers] and colleagues at [AX Technologies] have been testing and developing a small
liquid-fueled rocket engine and successfully used vortex cooling to protect a resin 3D printed combustion chamber
. (Video, embedded below.)
Vortex cooling works by injecting oxygen into the combustion chamber tangentially, just inside the nozzle of the engine, which creates a cooling, swirling vortex boundary layer along the chamber wall. The oxygen moves to the front end of the combustion chamber where it mixes with the fuel and ignites in the center. This does not protect the nozzle itself, which only lasts a few seconds before becoming unusable. However, thanks to the modular design of the test engine, only the small nozzle section had to be reprinted for every test. While this part could be manufactured using a metal 3D printer, the costs are still very high, especially at this experimental stage. The clear resin parts also allow the combustion observed and more accurate conclusions to be drawn from every test.
This engine intended to be used as a torch igniter for a much larger rocket engine. Fuel is injected into the front of the combustion chamber, where a spark plug is located to ignite the oxygen-fuel mixture. The flow of the oxygen and fuel is controlled by two servo-operated valves connected to a microcontroller, which is mounted with the engine on linear rails. This allows the test engine to move freely, and push against a load cell to measure thrust. The spark is created before the valves are opened to prevent a delayed ignition, which can blow up the engine, and getting the valve sequence and timing correct is critical. Many iterations and destroyed parts later, the [AX Technologies] team achieved successful ignition, with a clear supersonic Mach diamond pattern in the exhaust.
This is just one more example of 3D printing and cheap electronics allowing impressive progress on a limited budget. Another example is [Joe Barnard]’s progress in getting a
model rocket to land itself with a solid fuel engine
. Companies and organisations have been using
3D printed components in rocket engines
for a few years now, and we’ve even seen an
open source version
. | 16 | 5 | [
{
"comment_id": "6301342",
"author": "tomkcook",
"timestamp": "2020-12-08T13:08:06",
"content": "Somewhere recently I saw a video of someone making SLA-printed ceramic solid-fuel rocket engines. Their furnace they were using to cure the ceramics broke after the first attempt but it seems that it wo... | 1,760,373,260.758199 | ||
https://hackaday.com/2020/12/08/3d-printed-rigid-chain-mechanism/ | 3D Printed Rigid Chain Mechanism | Danie Conradie | [
"3d Printer hacks",
"Toy Hacks"
] | [
"3d printed",
"gzumwalt",
"mechanism",
"rigid chain"
] | One of the major advantages of 3D printing is the ability to quickly test and then iterate on mechanical designs. [gzumwalt] does a lot of this, and has recently been working on various versions of a
rigid chain mechanism
. (Video, embedded below.)
A rigid-chain mechanism is one way of fitting a long beam into a small box. It works similar to a zipper, meshing two separate “chains” with specially teeth designed to form a rigid beam. Due to clearances between the teeth, the beam tends to be a bit floppy. [gzumwalt] made various sizes of the mechanism, and also reduced the clearances on later versions to reduce the flop. He also integrated it into a cool
“snake in a basket” automaton
(second video below) by adding a reversible gearbox and a binary snap-action switch.
One possible use for this type of mechanism is for autonomously assembling long structures in space, as one of the 2017 Hackaday Prize finalist projects,
ZBeam
, proposed.
[gzumwalt] has not made the files available for download yet, but you can keep and eye on his
Instructables
pages for updates. He got a number of fascinating 3D printed devices already available, like a
domino laying machine
or a
WiFi controlled rover
. | 34 | 10 | [
{
"comment_id": "6301314",
"author": "Marc PELTIER",
"timestamp": "2020-12-08T10:06:43",
"content": "Rigid chains are used in theaters and performance halls :https://www.youtube.com/watch?v=XybtJ7OtbNA&feature=emb_logo",
"parent_id": null,
"depth": 1,
"replies": [
{
"commen... | 1,760,373,260.829476 | ||
https://hackaday.com/2020/12/07/inside-chip-8/ | Inside CHIP-8 | Al Williams | [
"Games",
"Retrocomputing",
"Software Development",
"Software Hacks"
] | [
"CHIP-8",
"cosmac elf",
"emulator",
"RCA 1802"
] | Certain old computers — most frequently those using the RCA 1802 — were fond of using an early form of byte-code interpreter for programs, especially games. The interpreter, CHIP-8, was very simple to create but offered high-level features that were tedious to recreate in the native assembly language. Because there are a fair number of simple games written in CHIP-8, there are of course, emulators for it, and [River Gillis] decided to
look inside the CHIP-8 byte code interpreter
.
Part of the power of CHIP-8 was it only had 35 virtual instructions. That was important when you were trying to shoehorn a game and the interpreter into a very small memory. Remember, in those days 1K of memory wasn’t an unusual number, although the prototypical CHIP-8 host would have 4K.
The virtual machine has 16 8-bit data registers and a stack. Since the idea was to create games, there are features useful for that purpose. For example, drawing to the screen (by default a 64×32 pixel screen) using sprites, you get information about any collisions on the screen automatically. The instructions offered some virtualization of the display and input device — usually, a hex keypad — and also provides the ability to convert binary numbers to binary coded decimal.
So the interpreter isn’t difficult to create by design. However, [River] has to emulate a target machine, and that’s where part two will pick up. However, if you are interested in retrocomputing, retrogaming, or you just want a better understanding of how a byte-coded interpreter works, this is a fun read with lots of code examples.
Making a custom virtual computer is actually not a bad idea when you are trying to conserve memory space and make development easier. Java uses the same idea on steroids, although mostly for different reasons. P-Code was another similar system and Forth, at its core, is the same basic concept.
It would be fun to put CHIP-8 on a small computer today to make
a super retro gaming console
. Or scarf up an old 1802 CPU — they are still available. You can also
make your own
.
Photo credit: RCA Cosmac VIP by [Dave Ruske]
CC BY 2.0 | 4 | 3 | [
{
"comment_id": "6301280",
"author": "Michael Black",
"timestamp": "2020-12-08T06:23:14",
"content": "The interpreter was featured in an article in Byte, I forget the year. The designer (and I think author) was Joseph Weisbecker, who created the 1802 among other things.There was something about the... | 1,760,373,260.709067 | ||
https://hackaday.com/2020/12/07/food-safe-printing-techniques/ | Food Safe Printing Techniques | Al Williams | [
"3d Printer hacks"
] | [
"3d printing",
"food",
"food safe"
] | One thing that always provokes spirited debate around the Hackaday bunker is just how dangerous is it to use 3D printed plastic in contact with food. We mostly agree it isn’t a good thing, but we also know some people do it regularly and they don’t drop dead instantly, either. [Jakub] decided to do
some testing and make some recommendations
. There’s even a video explaining the results.
Unlike a lot of what we’ve read about this topic in the past, [Jakub’s] post is well-researched and does actual testing including growing bacteria cultures from cups used for milk. He starts out identifying the EU and US regulations about what you can call food-grade. There’s also recognition that while a base plastic might be safe for contact with food, there’s no way to know exactly what additives and other things are in the plastic to change its properties and color.
The chemical makeup of the plastic is just one aspect of food safety. Another important aspect is the ability for harmful pathogens to lodge in the little voids and layers of the printed object. There are also the materials used in the printer. It is possible that safe plastic can be made unsafe in a dirty hot end or by contact with something noxious in the printer.
The gaps problem led [Jakub] to an inescapable conclusion: no matter what you print with, you’ll need to coat your prints to make them actually food safe. However, the coatings are not good for things like chopping boards or things you’ll expose to heat including microwaved food or hot dishwashers. If you think SLA resin might be better, he discusses the problems with that, too.
We’ve seen plenty of prints that
touch consumables
, even if they might not be totally safe. We’ve even
debated
the safety, but we didn’t grow any cultures. | 10 | 6 | [
{
"comment_id": "6301259",
"author": "Nick",
"timestamp": "2020-12-08T04:06:36",
"content": "I absolutely do not trust SLA resins to be food safe or biocompatible (apart from ridiculously expensive dental resins).",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": ... | 1,760,373,260.925556 | ||
https://hackaday.com/2020/12/07/cassette-synth-plays-with-speed-control/ | Cassette Synth Plays With Speed Control | Kristina Panos | [
"Musical Hacks"
] | [
"analog synth",
"cassette",
"Mellotron",
"potentiometer",
"synth"
] | Tape may not sound that great compared to vinyl, but cassette players can be tons of fun when it comes to making your own music. See for instance the Mellotron, or this relatively easy DIY alternative,
[Rich Bernett]’s Cassettone cassette player synth
.
The Cassettone works by substituting the trim pot that controls the speed of the tape player’s motor with a handful of potentiometers. These are each activated with momentary buttons located underneath the wooden keys. In the video after the break, [Rich] gives a complete and detailed guide to building your own. There’s also
a polished Google doc
that includes a schematic and the pattern pieces for making the cabinet.
Speaking of which, isn’t the case design nice? It’s built out of craft plywood but aged with varnish and Mod-Podged bits and bobs from vintage electronics magazines. This really looks like a fun little instrument to play.
Would you rather control your tape synth with a MIDI keyboard?
Just add Arduino
.
Thanks for the tip, [midierror]! | 10 | 6 | [
{
"comment_id": "6301243",
"author": "MLE_Online",
"timestamp": "2020-12-08T02:58:05",
"content": "This is such a fun synth. Thank you for the nice tutorial. I’m going to have to build one for myself, and it’s also given me some ideas for a different project I’m working on",
"parent_id": null,
... | 1,760,373,260.879515 | ||
https://hackaday.com/2020/12/09/pet-2001-emulator-on-2-of-hardware/ | PET 2001 Emulator On $2 Of Hardware | Bryan Cockfield | [
"ARM",
"Retrocomputing"
] | [
"blue pill",
"commodore",
"composite",
"emulator",
"keyboard",
"pet",
"PET 2001",
"retrocomputing",
"stm32",
"video"
] | 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
. | 20 | 6 | [
{
"comment_id": "6301959",
"author": "Bob",
"timestamp": "2020-12-10T00:47:04",
"content": "And it has a crappy keyboard, for that extra bit of retro authenticity!",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6301972",
"author": "Steven-X",
... | 1,760,373,261.078314 | ||
https://hackaday.com/2020/12/09/centos-is-dead-long-live-centos/ | CentOS Is Dead, Long Live CentOS | Jonathan Bennett | [
"Linux Hacks",
"News"
] | [
"CentOS",
"red hat",
"Rocky Linux"
] | 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. | 53 | 19 | [
{
"comment_id": "6301887",
"author": "thoriumbr",
"timestamp": "2020-12-09T21:19:59",
"content": "CentOS is dead… So long CentOS…My servers are Ubuntu most of the time. Some are Debian. I grew up using Debian and Ubuntu, so it’s personal choice, but CentOS was well regarded by me. I respected it a l... | 1,760,373,261.021839 | ||
https://hackaday.com/2020/12/09/who-says-solder-paste-stencils-have-to-be-cnc-cut/ | Who Says Solder Paste Stencils Have To Be CNC Cut? | Jenny List | [
"Tool Hacks"
] | [
"pet",
"reflow",
"solder paste",
"stencil"
] | Imagine having a surface mount kit that you’d like to stencil with solder paste and reflow solder, but which doesn’t come with a solder stencil. That was what faced [Honghong Lu], and she rose to the challenge
by taking a piece of PET sheet cut from discarded packaging and hand-cutting her own stencil
. It’s not a huge kit,
the Technologia Incognita 2020 kit
, but her home-made stencil still does an effective job.
So how does one create a solder stencil from household waste? In the video we’ve put below the break, she starts with her packaging, and cuts from it a square of PET sheet. It’s 0.24mm thick, which is ideal for the purpose. She then lays it over the PCB and marks all the pads with a marker pen, before cutting or drilling the holes for the pads. The underside is then sanded to remove protruding swarf, and the stencil can then be used in the normal way. She proves it by stenciling the solder paste, hand placing the parts, and reflowing the solder on a hotplate.
It’s clear that this is best suited to smaller numbers of larger components, and we’ll never use it to replace a laser-cut stencil for a thousand tiny 0201 discretes. But that’s not the point here, it’s an interesting technique for those less complex boards, and it’s something that can be tried by anyone who is curious to give stenciling and reflowing a go and who doesn’t have a project with a ready-cut stencil. And for that we like it.
Making your own stencils doesn’t have to include this rather basic method. They can be
etched
, or
even 3D printed
. | 19 | 10 | [
{
"comment_id": "6301858",
"author": "Hannes",
"timestamp": "2020-12-09T20:14:11",
"content": "LOVE the low budget approach!if you happen to have a cutting plotter and transparent printable sheets you can use those aswell. even after running 1000 pcbs through one sheet they still work fine for me. (... | 1,760,373,261.17738 | ||
https://hackaday.com/2020/12/09/hyperloop-fast-but-at-what-cost/ | Hyperloop: Fast, But At What Cost? | Lewin Day | [
"Business",
"Featured",
"Transportation Hacks"
] | [
"high speed rail",
"hyperloop",
"rail",
"railway",
"train"
] | When it comes to travelling long distances, Americans tend to rely on planes, while the Chinese and Europeans love their high speed rail. However, a new technology promises greater speed with lower fares, with fancy pods travelling in large tubes held at near-vacuum pressures. It goes by the name of Hyperloop.
Virgin Hyperloop recently ran the first-ever passenger test of a Hyperloop vehicle, reaching 100 mph on a short test track.
Spawned from an “alpha paper” put together by Elon Musk in 2013
, the technology is similar to other vactrain systems proposed in the past. Claiming potential top speeds of up to 760 mph, Hyperloop has been touted as a new high-speed solution for inter city travel, beating planes and high speed rail for travel time. Various groups have sprung up around the world to propose potential routes and develop the technology. Virgin Hyperloop are one of the companies at the forefront,
being the first to run a pod on their test track with live human passengers
, reaching speeds of 100 mph over a short 500 meter run.
It’s an exciting technology with a futuristic bent, but to hit the big time, it needs to beat out all comers on price and practicality. Let’s take a look at how it breaks down.
Fast But Compact
While many Hyperloop projects are under development around the world, the most-discussed proposal thus far has been the original idea of a route linking Los Angeles and San Francisco.
The initial claims from the Musk camp
were that a 350-mile Hyperloop system linking the two cities could be constructed for $6-7 billion, charging $20 for the lighting-quick 35 minute ride. Each pod would carry 28 passengers, with each pod spaced out by as little as 30 seconds in transit. Claimed maximum ridership for a two-tube system would be on the order of 15 million trips per year. Multiplying that out, that comes to $300 million in revenue generated by the heavily-patronised system.
Obviously, with ticket prices so low, journey times so short, and with far less fuss compared to taking a flight, the Hyperloop looks promising on paper. However, digging deeper, the fundamentals of the project don’t look so rosy. With such a low number of passengers per pod, the total flow rate of passengers through the system is limited,
on the order of just 3360 passengers per hour
. Projected land costs are likely far in excess of the mere $1 billion cited in the original Hyperloop paper,
leading many to suspect the $6 billion cost is likely off by a factor of 10 or more, with tickets more realistically costing $1000 apiece.
Hyperloop designs struggle to match traditional high-speed rail when looking at traditional transit metrics like passengers per hour.
For comparison’s sake, the politically troubled high speed rail project in California aims to link the same two cities with conventional high-speed rail.
Breaking ground in 2015
, the project is targeted for completion sometime before 2030. But to date it has faced all manner of complications, not least with the acquisition of suitable rights-of-way to build the railway on. Land acquisition is often the biggest hurdle for such transport links, and this makes up much of the project’s $68 billion budget. The railway plans to operate at 220 mph, with a targeted travel time of under 2 hours 40 minutes from San Francisco to LA on a 380 mile route. Projected ridership is on the order of 16 million in 2029,
ramping up to 35.6 million by 2033.
Fares are on the order of $100 for the full route, leading to expected revenue of $2.2 billion by 2033.
Crunching the Per-Mile Costs
With a proven technology like high speed rail costing tens of billions of dollars, it’s somewhat difficult to believe a never-before-built Hyperloop system could be cheaper. This is
before
considering the technical difficulties of keeping huge stretches of large-diameter tube at low enough pressures to maintain high speed travel, or the safety concerns of how to rescue passengers stuck inside a broken-down pod. Other than speed, in every other metric, Hyperloop seems to fall down relative to the traditional high-speed rail option. As a bonus, at least on the Californian route, that rail option is already under construction, and it promises better-located stations, too.
Large, long-distance vacuum tubes are significantly more complex than a normal railway, and present issues around maintenance and rescues.
Further studies have only confirmed the higher costs that could realistically be expected of such a system. Modelling by Virgin Hyperloop One in 2016
estimated a per-mile cost of $84 to $121 million
for a cut-down 107-mile Bay Area project. This compares to a projected cost of $178 million per mile for the full Californian high speed rail project. It’s difficult to understand how a complex Hyperloop system could be cheaper to build than a simple set of rails, but even if it can, proposals still fall down when it comes to the lower number of passengers per hour able to flow through the system.
Given we’ve only just seen the first human test of a Hyperloop prototype, it’s perhaps too early to discount the technology entirely. However, thus far, it fails to present a sustainable business case unless passenger flow rates can be increased significantly. It’s a similar problem that doomed the
Concorde
, and it could happen again here. But with so many projects underway around the world, we may yet see a real working Hyperloop in operation sooner rather than later. | 162 | 35 | [
{
"comment_id": "6301810",
"author": "Jan Praegert",
"timestamp": "2020-12-09T18:14:17",
"content": "Hyperloop is a problem maximizing concept: take everything, that is difficult and put it into a project plus not making anything substantial better than existing, working solutions.",
"parent_id"... | 1,760,373,261.543254 | ||
https://hackaday.com/2020/12/09/mind-controlled-beer-pong-gets-easier-as-you-drink/ | Mind-Controlled Beer Pong Gets Easier As You Drink | Kristina Panos | [
"Arduino Hacks",
"Games"
] | [
"arduino",
"arduino nano",
"beer pong",
"beer pong table",
"mind control"
] | Wouldn’t it be nice if beer pong could somehow get easier the more you drink? You know, so you can drink more? [Ty Palowski] has made it so with
automated, mind-controlled beer pong
.
[Ty] started by making a beer pong table that moves the cups back and forth at both ends. An Arduino Nano controls a stepper that controls a slider, and the cups move with the slider through the magic of magnets. The mind control part came cheaper than you might think. Back in 2009, Mattel released a game called Mind Flex that involves an EEG headset and using brain waves to guide a foam ball on a stream of air through a little obstacle course. These headsets are available for about $12 on ebay, or at least they were before this post went up.
[Ty] cracked open the headset added an HC-06 Bluetooth module to talk to the Arduino. It’s using a program called Brainwave OSC to get the raw data from the headset and break it into levels of concentration and relaxation. The Arduino program monitors the attention levels, and when a certain threshold of focus is reached, it moves the cups back and forth at a predetermined speed ranging from 1 to an impossible-looking 10. Check out the two videos after the break. The first one covers the making of the the automatic beer pong part, and the second is where [Ty] adds mind control.
We’ve seen a different headset — the hacker-friendly NeuroSky Mindwave — pop up a few times.
Here’s one that’s been hacked to induce lucid dreaming
.
Via
r/duino | 1 | 1 | [
{
"comment_id": "6301965",
"author": "poopman104",
"timestamp": "2020-12-10T01:06:33",
"content": "Beer pong already gets easier the more you drink !",
"parent_id": null,
"depth": 1,
"replies": []
}
] | 1,760,373,261.580377 | ||
https://hackaday.com/2020/12/09/north-american-field-guide-to-rail-cars/ | North American Field Guide To Rail Cars | Kristina Panos | [
"Featured",
"Interest",
"Original Art",
"Transportation Hacks"
] | [
"boxcar",
"Field Guide",
"flat car",
"gondola",
"rail car",
"railroad",
"train"
] | Trains are one of the oldest and most reliable ways we have of transporting things and people over long distances. But how often do you think about trains? Where I live, they can clearly be heard every hour or so. I should be used to the sound of them by now, but I like it enough to stop what I’m doing and listen to the whistles almost every time. In the early morning quiet, I can even hear the dull roar as it rumbles down the track.
I recently got a front row seat at a railroad crossing, and as the train chugged through the intersection, I found myself wondering for the hundredth time what all the cars had in them. And then, as I have for the last twenty or thirty years, I wondered why I never see a caboose anymore. I figured it was high time to answer both questions.
Image via
GBX
Boxcar
Boxcars are probably the most easily identifiable after the engine and the caboose.
Boxcars carry crated and palletized freight like paper, lumber, packaged goods, and even boxes. Refrigerated box cars carry everything from produce to frozen foods.
Boxcars (and barns for that matter) are traditionally a rusty red color because there were few paint options in the late 1800s, and iron-rich dirt-based paint was dirt cheap.
Flat car with bulkheads. Image via
YouTube
Flat Car
Standard, no-frills flat cars are the oldest types of rail cars. These are just big, flat platform cars that can carry anything from pipe, rail, and steel beams to tractors and military vehicles.
Flat cars come in different lengths and are also made with and without bulkheads that help keep the cargo in place. Some flat cars have a depression in the middle for really tall or heavy loads, like electrical transformers.
Image via
Ship Cars Now
Auto Rack
As the name implies, auto racks carry passenger cars, trucks, and SUV from factories to distributors. They come in two- and three-level models, although there have been specialized auto racks over the years.
Perhaps the strangest auto rack of them all was
the Vert-a-Pac
. When Chevrolet came up with the Vega in the gas-conscious 1970s, they wanted to be able to move them as cheaply as possible, so they shipped the cars on end. If you’re wondering about all the fluids in the car when they were upended, a special baffle kept oil from leaking out, the batteries were capped, and the windshield washer fluid bottle was positioned at an angle.
Image via
YouTube
Center-beam Flat Car
These are the see-through cars that look like framed-out walls when they’re empty. A beam runs down the center, and freight is loaded up on either side and tied down from top to bottom.
Some center beam flat cars have a gallery of oval-shaped windows running down the middle
, and those are my personal favorite. Center beam flat cars typically carry bundled goods like lumber, drywall, and building supplies.
Image via
Steelcar
Gondola
Gondolas are one of the oldest types of rail cars. They are basically a box car that’s half as tall. Gondolas carry things like scrap metal, logs, lumber, aggregates, steel, sand, copper, and iron ore.
Before the American railroads were built, coal was carried down the Potomac River in wooden boats that were called gondolas after the famous Venetian vessels. Once the railroad came into being, these boat-like cars were made for carrying coal.
Image via
Wikipedia
Coil Car
Coil cars get their name from the coiled steel bundles they were built to carry. They can also carry other stock like steel plates. Coil cars come in different capacities and lengths depending on the cargo.
Although they don’t look like gondolas, coil cars are technically a subset of them, and the business part of the car is often referred to as the gondola.
Image via
Steelcar
Hopper
Hoppers are tall gondolas with openings at the bottom. These carry free-flowing stuff and could be thought of as a silo on wheels. Typical freight includes cement, roofing granules, fertilizer, and commodities like corn, sugar, wheat, barley, and rice.
Hoppers come in both covered and uncovered models. The uncovered type carry things like coal, sand, and rock. Gondolas and hoppers can both be emptied with a
rotary car dumper
, which is every bit as awesome as it sounds.
One of the few Schnabel cars. Image via
Wikipedia
Schnabel Car
There are only about 30 of these in North America, but are definitely worth including in case you encounter one some day. Schnabel cars are meant for large, heavy loads like transformers are are designed so that the load becomes part of the car. A pair of arms hold the load in place and distributes the load evenly over the span of the car.
The largest Schnabel car in operation
was built to transport nuclear reactor containment vessels. It’s 231 feet long, has 36 axles, and weighs 400 tons.
Image via
American Rails
Tank Car
Tank cars are also somewhat self-explanatory. They can carry compressed and uncompressed liquids like chemicals, molasses, water, and diesel. Tank cars can be pressurized or insulated, and they are usually owned by the chemical companies and not railroads.
The tank car came about in the 1860s as a way to transport oil
. Prior to this, railroads used a combination of gondolas, flat cars, and boxcars to carry everything from lumber to barrels of molasses.
Image via
Wikipedia
Well Car
Well cars are a lot like flat cars, but are specially designed to hold shipping containers for intermodal transport. They’re also called stack cars and double-stack cars.
Well cars have only been around for about 40 years, and flat cars were used to transport shipping containers prior to their invention.
Image via
Niles Canyon Railway
And Of Course, the Caboose
Although they aren’t used anymore, no rail car field guide would be complete without the caboose pulling up the rear. These cute little cars gave the crew a place to cook, eat, sleep, or catch up on paperwork. Many cabooses had a cupola which served as a lookout point to check for fires and other problems.
Since the 1980s, cabooses have been replaced with a small box, called an “end of train device”, to save money. The box does everything the humans did and more — such as tell the conductor how fast the rear end is moving — but it lacks the charm of the caboose.
The next time you have to wait for a train, maybe you’ll check out the cars instead of checking your phone. Who knows, maybe you’ll even see a Schnabel car someday. | 55 | 25 | [
{
"comment_id": "6301735",
"author": "Gravis",
"timestamp": "2020-12-09T15:06:10",
"content": "WOW! That is a BIG transformer on the Schnabel Car.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6301803",
"author": "Ren",
"timestamp": "2020-12... | 1,760,373,261.813031 | ||
https://hackaday.com/2020/12/09/speaker-snitch-tattles-on-privacy-leaks/ | Speaker Snitch Tattles On Privacy Leaks | Bryan Cockfield | [
"Peripherals Hacks"
] | [
"arduino",
"home-assistant",
"IoT",
"man-in-the-middle",
"microphone",
"networking",
"privacy",
"raspberry pi",
"smart device"
] | A wise senator once noted that democracy dies with thunderous applause. Similarly, it’s also how privacy dies, as we invite more and more smart devices willingly into our homes that are built by companies that don’t tend to have our best interests in mind. If you’re not willing to toss all of these admittedly useful devices out of the house but still want to keep an eye on what they’re doing, though, [Nick Bild]
has a handy project that lets you keep an eye on them when they try to access the network
.
The device is built on a Raspberry Pi that acts as a middle man for these devices on his home network. Any traffic they attempt to send gets sent through the Pi which sniffs the traffic via a Python script and is able to detect when they are accessing their cloud services. From there, the Pi sends an alert to an IoT Arduino connected to an LED which illuminates during the time in which the smart devices are active.
The build is an interesting one because many smart devices are known to listen in to day-to-day conversation even without speaking the code phrase (i.e. “Hey Google” etc.) and this is a great way to have some peace-of-mind that a device is inactive at any particular moment. However, it’s not a foolproof way of guaranteeing privacy, as plenty of devices might be accessing other services, and still other devices have
even been known to ship with hidden hardware
. | 33 | 11 | [
{
"comment_id": "6301697",
"author": "Gravis",
"timestamp": "2020-12-09T13:26:22",
"content": "The only winning move is not to play.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6301716",
"author": "Steve L",
"timestamp": "2020-12-09T14:16:... | 1,760,373,261.69901 | ||
https://hackaday.com/2020/12/07/a-brain-transplant-for-an-uncommon-smart-bulb/ | A Brain Transplant For An Uncommon Smart Bulb | Jenny List | [
"home hacks"
] | [
"ESP8266",
"OPL1000",
"Smart Bulb",
"tasmota"
] | By now it’s a hardware hack that’s become common enough to be unremarkable, taking a smart light bulb or other mains switchable appliance and replacing its firmware with an open-source equivalent such as Tasmota. But what can be done when a new device
is found to have a microcontroller unsupported by any open-source equivalents
? If you are [Luca Dentella], you don’t throw in the towel and buy another one with a known processor, instead you reverse engineer it enough to give it a brain transplant of an ESP8266 module.
The Fcmila branded smart bulb in question was found to have a relatively unknown Chinese SoC, the Opulinks OPL1000.
Since this couldn’t even raise a serial port
it was more trouble than it was worth to write software for it, so instead he spent a while reverse engineering its schematic and electrical protocols, before
grafting in a Wemos D1 ESP8266 board
. He’s made a video about the project which you can see below the break.
Thankfully the majority of smart bulbs on the market seem to use more familiar hardware
that can be flashed with relative ease
. | 6 | 3 | [
{
"comment_id": "6300968",
"author": "Ben",
"timestamp": "2020-12-07T10:27:43",
"content": "I’m more amazed that there are bulbs that *aren’t* using the same tasmota-compatible ESP chip all the rest are… Seems like it wouldn’t be worth the effort to develop a bulb not using it!",
"parent_id": nu... | 1,760,373,261.627507 | ||
https://hackaday.com/2020/12/06/these-micro-mice-have-macro-control/ | These Micro Mice Have Macro Control | Kerry Scharfglass | [
"Robots Hacks"
] | [
"3d printing",
"KiCAD",
"micro mouse",
"micromouse",
"resin printer",
"robot",
"tiny robots"
] | Few things fascinate a simple Hackaday writer as much as a tiny robot. We’ve been watching [Keri]’s utterly beguiling micromouse builds for a while now, but the
fifth version of the KERISE series
(
machine translation
) of ‘bots takes the design to new heights.
A family of mice v1 (largest) to v5 (smallest)
For context,
micromouse
is a competition where robots complete to solve mazes of varying pattern but standardized size by driving through them with no guidance or compute offboard of the robot itself. Historically the mazes were 3 meter squares composed of a 16 x 16 grid of cells, each 180mm on a side and 50mm tall, which puts bounds on the size of the robots involved.
What are the hallmarks of a [Keri] micromouse design? Well this is micromouse, so everything is pretty small. But [Keri]’s attention to detail in forming miniaturized mechanisms and 3D structures out of PCBs really stands out. They’ve been building micromouse robots since 2016, testing new design features with each iteration. Versions three and four had a wild suction fan to improve traction for faster maneuvering, but the KERISE v5 removes this to emphasize light weight and small size. The resulting vehicle is a shocking 30mm x 32mm! We’re following along through a translation to English, but we gather that [Keri] feels that there is still plenty of space on the main PCBA now that the fan is gone.
The KERISE v5 front end
The processor is a now familiar ESP32-PICO-D4, though the wireless radios are unused so far. As far as environmental sensing is concerned the v5 has an impressive compliment given its micro size. For position sensing there are custom magnetic encoders and a 3 DOF IMU. And for sensing the maze there are four side-looking IR emitter/receiver pairs and one forward-looking VL6180X laser rangefinder for measurements out to 100 or 150mm. Most of these sensors are mounted on little PCB ‘blades’ which are double sided (check out how the PCB shields the IR emitter from it’s receiver!) and soldered into slots perpendicular to the PCBA that makes up the main chassis. It goes without saying that the rest of the frame is built up of custom 3D printed parts and gearboxes.
If you’d like to build a KERISE yourself, [Keri] has what looks to be complete mechanical, electrical, and firmware sources for
v1
,
v2
, and
v3
on
their Github
. To see the KERISE v5 dance on a spinning sheet of paper, check out the video after the break. You don’t want to miss it!
新作 KERISE v5 で宴会芸できたぞ！
pic.twitter.com/vjZunGYJ4w
— けり (@kerikun11)
November 22, 2020 | 7 | 6 | [
{
"comment_id": "6300928",
"author": "Grumpy Old Coot",
"timestamp": "2020-12-07T06:33:04",
"content": "That is impressive! Even more so, considering I have that coin on my desk and can directly relate to how small it actually is!",
"parent_id": null,
"depth": 1,
"replies": []
},
{
... | 1,760,373,262.055621 | ||
https://hackaday.com/2020/12/06/a-uv-curing-wand-for-everyone/ | A UV Curing Wand For Everyone | Matthew Carlson | [
"LED Hacks",
"The Hackaday Prize",
"Tool Hacks"
] | [
"2020 Hackaday Prize",
"curing",
"uv"
] | The average person’s experience with an ultraviolet (UV) wand is getting a cavity at the dentist. However, anyone with a resin-based 3d printer knows how important a UV curing system is. Often times some spots on a print need a little bit of extra UV to firm up. [Mile] has set out to
create an open-source UV curing wand named Photon that is cost-effective and easy to build
.
What’s interesting here is that there are dozens if not hundreds of UV curing systems ranging from $5 LED flashlights to larger industrial flood systems. [Mile] dives right in and shows the trade-offs that those cheaper modules are making as well as what the commercial systems are doing that he isn’t. [Mile’s] Photon wand tries to be energy efficient with more irradiated power while staying at a lower cost. This is done by carefully selecting the CSP LEDs instead of traditional wire-bonded and making sure the light source is properly focused and cooled. From the clean PCB and slick case, it is quite clear that [Mile] has gone the extra step to make this production-friendly. Since there are two industry-standard wavelengths that resins cure at (364nm and 405nm), the LED modules in Photon are user-replaceable.
What we love about this project is looking past what is readily available and diving deep. First understanding the drawbacks and limitations of what is there, then setting a goal and pushing through to something different. This isn’t
the first UV curing tool we’ve seen recently
, so it seems there is a clear need for something better that’s what is out there today.
The
Hackaday
Prize2020
is Sponsored by: | 12 | 7 | [
{
"comment_id": "6300904",
"author": "Joel",
"timestamp": "2020-12-07T03:34:07",
"content": "Before we built our version of >100W LED UVA curing chambers, I used a violet laser pointer for UV resins (note the 455nm true blue laser I tried did not work with any of the acrylic resins). However, some 5... | 1,760,373,261.862953 | ||
https://hackaday.com/2020/12/06/hackaday-links-december-6-2020/ | Hackaday Links: December 6, 2020 | Dan Maloney | [
"Hackaday Columns",
"Hackaday links"
] | [
"ai",
"Arecibo",
"Bring A Hack",
"enigma",
"hackaday links",
"Haybusa2",
"machine learning",
"Remoticon",
"speech recognition",
"training data"
] | By now you’ve no doubt heard of the sudden but not unexpected demise of the iconic Arecibo radio telescope in Puerto Rico. We have been covering the agonizing end of Arecibo from almost
the moment the first cable broke in August
to
a eulogy
, and most recently
its final catastrophic collapse this week
. That last article contained amazing video of the final collapse, including up-close and personal drone shots of the cable breaking. For a more in-depth analysis of the collapse, it’s hard to beat
Scott Manley’s frame-by-frame analysis
, which really goes into detail about what happened. Seeing the paint spalling off the cables as they stretch and distort under loads far greater than they were designed for is both terrifying and fascinating.
Exciting news from Australia as the sample return capsule from JAXA’s Hayabusa2 asteroid explorer
returned safely to Earth Saturday
. We covered Hayabusa2 in
our roundup of extraterrestrial excavations
a while back, describing how it used both a tantalum bullet and a shaped-charge penetrator to blast regolith from the surface of asteroid 162173 Ryugu. Samples of the debris were hoovered up and hermetically sealed for the long ride back to Earth, which culminated in the fiery re-entry and safe landing in the midst of the Australian outback. Planetary scientists are no doubt eager to get a look inside the capsule and analyze the precious milligrams of space dust. In the meantime, Hayabusa2, with 66 kilograms of propellant remaining, is off on an extended mission to visit more asteroids for the next eleven years or so.
The 2020 Remoticon has been wrapped up for most of a month now, but one thing we noticed was how much everyone seemed to like the Friday evening Bring-a-Hack event that was hosted on Remo. To kind of keep that meetup momentum going and to help everyone slide into the holiday season with a little more cheer,
we’re putting together a “Holiday with Hackaday & Tindie” meetup on Tuesday, December 15 at noon Pacific time
. The details haven’t been shared yet, but our guess is that this will certainly be a “bring-a-hack friendly” event. We’ll share more details when we get them this week, but for now, hop over to the Remo event page and reserve your spot.
On the Buzzword Bingo scorecard, “Artificial Intelligence” is a square that can almost be checked off by default these days, as companies rush to stretch the definition of the term to fit almost every product in the neverending search for market share. But even those products that actually have machine learning built into them are only as good as the data sets used to train them. That can be a problem for voice-recognition systems; while there are massive databases of utterances in just about every language, the likes of Amazon and Google aren’t too willing to share what they’ve leveraged from their smart speaker using customer base. What’s the little person to do? Perhaps
the People’s Speech database
will help. Part of the
MLCommons
project, it has 86,000 hours of speech data, mostly derived from audiobooks, a clever source indeed since the speech and the text can be easily aligned. The database also pulls audio and the corresponding text from Wikipedia and other random sources around the web. It’s a small dataset, to be sure, but it’s a start.
And finally, divers in the Baltic Sea have dredged up a bit of treasure:
a Nazi Enigma machine
. Divers in Gelting Bay near the border of Germany and Denmark found what appeared to be an old typewriter caught in one of the abandoned fishing nets they were searching for. When they realized what it was — even crusted in 80-years-worth of corrosion and muck some keys still look like they’re brand new — they called in archaeologists to take over recovery. Gelting Bay was the scene of a mass scuttling of U-boats in the final days of World War II, so this Engima may have been pitched overboard before by a Nazi commander before pulling the plug on his boat. It’ll take years to restore, but it’ll be quite a museum piece when it’s done. | 4 | 1 | [
{
"comment_id": "6300931",
"author": "ahmet",
"timestamp": "2020-12-07T06:55:11",
"content": "not engima but enigma",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6301005",
"author": "ziggurat29",
"timestamp": "2020-12-07T14:26:23",
"... | 1,760,373,261.906778 | ||
https://hackaday.com/2020/12/06/leaking-data-by-ultrasound/ | Leaking Data By Ultrasound | Lewin Day | [
"digital audio hacks",
"Security Hacks"
] | [
"ultrasound"
] | Human ears are capable of perceiving frequencies from roughly 20 Hz up to 20 kHz, at least when new. Correspondingly, our audio hardware is designed more or less to target these frequencies. However, there’s often a little extra capability at the upper edges,
which [Jacek] shows can be exploited to exfiltrate data.
The hack takes advantage of the fact that most computers can run their soundcards at a sample rate of up to 48 kHz, which thanks to the Nyquist theorem means they can output frequencies up to around 24 kHz — still outside the range of human hearing. Computers and laptops often use small speaker drivers too, which are able to readily generate sound at this frequency. Through the use of a simple Linux shell script, [Jacek] is able to have a laptop output Morse code over ultrasound,
and pick it up with nothing more than a laptop’s internal microphone at up to 20 meters away.
[Jacek] enjoys exploring alternative data exfiltration methods;
he’s previously experimented with Ethernet leaks on the Raspberry Pi.
Of course, with any airgap attack, the real challenge is often getting the remote machine to run the exfiltration script when there’s no existing remote admin access to be had. Video after the break. | 19 | 9 | [
{
"comment_id": "6300851",
"author": "jalnl",
"timestamp": "2020-12-06T21:23:02",
"content": "Also a problem: internal speakers are typically not capable of producing these high frequencies.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6300864",
"a... | 1,760,373,262.112057 | ||
https://hackaday.com/2020/12/06/no-battery-pressure-sensors-for-bike-tyres/ | No-Battery Pressure Sensors For Bike Tyres | Lewin Day | [
"Misc Hacks"
] | [
"bicycle",
"bike",
"NFC",
"tire",
"Tire pressure",
"tire pressure sensor"
] | Finding out you’ve got a flat tyres halfway into a long ride is a frustrating experience for a cyclist. Maintaining the
While the epoxy does a great job of sealing the PCB to the valve extension, the overmoulding process would likely be key to producing a product with shelf-quality fit and finish. This test run was done with 3D printed ABS moulds.
correct tyre pressures is key to a good ride, whether you’re stacking up the miles on the road or tackling tricky single track in the mountains.
[CaptMcAllister] has put together a device that makes keeping an eye on your tyres easy.
The device consists of an ultra low power microcontroller from Texas Instruments, paired with a pressure sensor. Set up for Near Field Communication, or NFC, it’s designed to be powered by the smartphone that queries the microcontroller for a reading.
We featured a prototype back in 2015
which required mounting the device within the inner tube of the tyre itself. However, this required invasive installation and the devices tended to wear out over time due to flex damaging the delicate copper coil antenna.
The new design consists of the same microcontroller hardware, but mounted in a modified valve extension that fits to the fill valve of the bicycle tyre. The PCB is directly epoxied on to the valve extension, ensuring air can’t leak out over time. The assembly is then overmoulded in an injection moulding process to provide further sealing and protection against the elements. This should help immensely in rough-and-tumble mountain biking applications.
The new device provides a simple screw-on solution for tire pressure monitoring that’s set and forget — no batteries required. [CaptMcAllister] is currently investigating options for a production run, and given the simple design, we imagine it couldn’t be too hard to rattle off a few hundred or thousand units. We could imagine it would also pair well with a microcontroller, NFC reader, and a display setup on the handlebars to give live readings where required. We look forward in earnest to seeing where this project goes next! | 55 | 18 | [
{
"comment_id": "6300809",
"author": "mrehorst",
"timestamp": "2020-12-06T18:34:23",
"content": "I made the mistake of installing urethane rubber strips inside my bike tires to “protect” from flats due to thorns, glass, etc. I suddenly started having more flat tires than ever because the edge/corner... | 1,760,373,262.004858 | ||
https://hackaday.com/2020/12/06/parkinsons-spoon-uses-control-theory-for-good/ | Parkinson’s Spoon Uses Control Theory For Good | Al Williams | [
"Arduino Hacks",
"Robots Hacks"
] | [
"control theory",
"parkinson's",
"pid",
"spoon"
] | When we first saw [Barqunics’] design for
a self-stabilizing spoon
for people suffering from Parkinson’s disease, we wondered how well something like that could work. But take a look at the video below and you’ll see this does a fine job of responding to the user’s hand movements and keeping the spoon perfectly level through a wide range of motion.
There’s at least one commercial product that attempts to stabilize a spoon in the same way so that people suffering from that affliction can retain a measure of independence. This shows that you don’t need injection molding and factory made boards to prove the concept. An MPU6050 provides sensor information and two servo motors control the spoon using PID control.
PID — short for proportional, integral, derivative — is a way to adjust something to a desired point. For example, consider trying to heat a cup of water to 95 °C. If you simply turn the heater on full blast until you get to 95 °C, the water will actually get hotter because you’ll overshoot. Using PID, the amount of heating provided will depend on how far off you are now (proportional), how far off you’ve been over the long term (integral), and how much change you’ve effected recently (derivative). The same algorithm works for spoon-balancing and many other types of controls.
This isn’t the first
bootstrapped assistive spoon project
we’ve seen. We even looked at the
commercial version
, awhile back. | 18 | 12 | [
{
"comment_id": "6300778",
"author": "Innocent Bystander",
"timestamp": "2020-12-06T16:33:51",
"content": "Congratulations, for making the world better",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6300780",
"author": "Ec",
"timestamp": "2020-12-06T16... | 1,760,373,262.168963 | ||
https://hackaday.com/2020/12/07/the-gatwick-drone-finally-someone-who-isnt-us-asks-whether-it-ever-really-existed/ | The Gatwick Drone: Finally Someone Who Isn’t Us Asks Whether It Ever Really Existed | Jenny List | [
"drone hacks",
"News"
] | [
"drone",
"drone law",
"Gatwick",
"Gatwick airport"
] | It’s taken two years, but finally it’s happened. Finally a respected national mass-media outlet has asked the question Hackaday were posing shortly after the event: what evidence was there that a drone was actually present in restricted airspace?
The Guardian newspaper in the UK is the outlet looking into
the mystery of the Gatwick drone
. It was the worldwide story of the moment around this time back in 2018 when the London airport closed down for several days in response to a series of drone reports. The assumption being put forward was that bad actors in the drone community were to blame, but there was significant disquiet in those ranks as the police and media story simply lacked credibility to anyone with knowledge of drones. At no point could they point to evidence that held water,
the couple they arrested turned out to be innocent
, and eventually a police officer admitted that there might not have been a drone after all. The damage had by then been done, as
Received Opinion
had it that irresponsible drone enthusiasts had put lives in danger and caused huge economic damage by closing an airport for several days.
The Guardian piece paints a fascinating and detailed picture of the events surrounding the investigation, by bringing the investigative journalism resources of a national newspaper into tracing and interviewing people involved from all sides. They talk to former Gatwick employees, off-the-record police officers with knowledge of the case, a drone specialist journalist, and the drone community including some of its members with significant professional experience in the world of aviation. It talks about the slow drip-feed of freedom of information requests revealing the machinations behind the scenes and furthermore the continuing lack of tangible proof of a drone. It’s very much worth a read, and we hope it will prompt further investigation of the events without the focus being on a non-existent drone.
We’d like to invite you to read
Hackaday’s coverage from a few days after the event
, and for an overview of the subject including the later Heathrow event,
watch the CCCamp talk I presented on the topic in 2019
. Then as now, our wish is for competent police investigations, responsible media reporting of drone stories, and credible official investigations of air proximity reports surrounding drones.
Header: Lucy Ingham,
CC BY-SA 4.0
. | 70 | 16 | [
{
"comment_id": "6301164",
"author": "Edward Nardella",
"timestamp": "2020-12-07T21:38:10",
"content": "Where did all the comments go? There were at least 3 last I looked!",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6301231",
"author": "Pritchard"... | 1,760,373,262.585476 | ||
https://hackaday.com/2020/12/07/sinclair-ql-repairs-and-restoration/ | Sinclair QL Repairs And Restoration | Al Williams | [
"Retrocomputing"
] | [
"Clive Sinclair",
"microcassete",
"microdrive",
"ql",
"retrocomputing",
"sinclair",
"sinclair ql"
] | [Noel] was in possession of two non-working Sinclair QLs and made a series of videos about his
attempts to repair and restore them
. If you don’t remember the QL, it was a computer by the famous Clive Sinclair and while it was ahead of its time in some ways, it didn’t become as ubiquitous as some of its siblings or the IBM PC. It did, however, develop an almost cult-like following. You can see the trilogy of videos, below.
The machine was sophisticated for its day–after all, the QL was for quantum leap. Based on a Motorola 68008 processor running at 7.5 MHz, the QL included 128 KB of RAM and could handle up to 896 KB, a respectable amount for 1984. It even had a proprietary network interface. However, it was especially well known for having a pair of microtape drives. These were nicer than cassette tapes but perhaps not as handy as floppy disks. They were, however, cheaper to put into a computer. While there was an official operating system, it wasn’t long before most QL users switched to Minerva, a better OS.
You can really see the differences in construction techniques for 1980’s consumer electronics and today. Of course, Sinclair was known to have reasonably inexpensive gear, so that contributes, too. One interesting thing about the video: [Noel] isn’t an expert on the QL so the video documents how he approached a new problem. Even if you don’t want to fix a QL, some of the process would be useful next time you are facing an unfamiliar board.
The two computers were slightly different versions. One had an unpopulated spot for an EPROM that the newer one didn’t provide. [Noel] built a simple adapter to allow an EPROM to work with either computer. Minerva’s EPROM had a diagnostic that identifies bad chips and that was very helpful with identifying the bad RAM chips. The second video covers some of the physical restorations and the third video covers the microdrives in detail. Overall, an interesting watch.
Sinclair was pretty obsessed with the
microdrives
, but they never really caught on. He did have a very interesting
history
in the electronics marketplace. | 9 | 5 | [
{
"comment_id": "6301123",
"author": "Danjovic",
"timestamp": "2020-12-07T19:57:27",
"content": "Oh the QL was a dream machine at the time it was rumored. Yet today I wish I had one :) !",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6301134",
"autho... | 1,760,373,262.390965 | ||
https://hackaday.com/2020/12/07/how-to-get-into-lost-wax-casting-with-a-dash-of-3d-printing/ | How To Get Into Lost Wax Casting (with A Dash Of 3D Printing) | Adam Zeloof | [
"Art",
"Hackaday Columns",
"how-to",
"Slider"
] | [
"3d printing",
"investment casting",
"Lost wax casting",
"metal",
"molten metal",
"sla"
] | I’ve always thought that there are three things you can do with metal: cut it, bend it, and join it. Sure, I knew you could melt it, but that was always something that happened in big foundries- you design something and ship it off to be cast in some large angular building churning out smoke. After all, melting most metals is hard. Silver melts at 1,763 °F. Copper at 1,983 °F. Not only do you need to create an environment that can hit those temperatures, but you need to build it from materials that can withstand them.
Turns out, melting metal is not so bad. Surprisingly, I’ve found that the hardest part of the process for an engineer like myself at least, is creating the pattern to be replicated in metal. That part is pure art, but thankfully I learned that we can use technology to cheat a bit.
When
I decided to take up casting earlier this year
, I knew pretty much nothing about it. Before we dive into the details here, let’s go through a quick rundown to save you the first day I spent researching the process. At it’s core, here are the steps involved in lost wax, or investment, casting:
Make a pattern: a wax or plastic replica of the part you’d like to create in metal
Make a mold: pour plaster around the pattern, then burn out the wax to leave a hollow cavity
Pour the metal: melt some metal and pour it into the cavity
I had been kicking around the idea of trying this since last fall, but didn’t really know where to begin. There seemed to be a lot of equipment involved, and I’m no sculptor, so I knew that making patterns would be a challenge. I had heard that you could 3D-print wax patterns instead of carving them by hand, but the best machine for the job is an SLA printer which is prohibitively expensive, or so I thought.
A Pattern of Creativity
That perception changed when
my brother Sam
picked up an Elegoo Mars 3D printer. I was surprised that you could get a sub-$300 SLA machine, and absolutely floored by the quality of prints it produced. I was able to pick up some printer resin designed for investment casting, and printed my first pattern- two tiny Pikachus and a rook.
PikaSprue — A 3D printed Pikachu affixed to some sprue wax
I use
PowerResins WAX
for my printing resin. It’s pricey but prints really well and burns out cleanly. It does have issues adhering to the build platform, but you can get around that by priming the plate. Some people recommend painting on a few payers of resin and curing them with UV light before printing. I follow a tip I found in
this YouTube video
and just include a few primer layers in my print. This may seem a bit wasteful, but if it keeps one print from coming off the plate, it’s worth it.
Of course, we can go the classic route here and make our patterns by hand instead. I’ve taken a swing at this and had success making simple things like a ring which I carved from wax, but I would be lost on more intricate designs. Like I said, I’m no sculptor, but it’s fun to carve a pattern manually. Wax is available in many forms — sheets, blocks, ring blanks, and others. There are some real nice carving tools out there which I own now, but my first ring was formed with a pocket knife, a file, and a disc sander. It’s not all about removing material either- since wax is easy to melt, it’s common to fuse parts together to create a finished piece.
A fully-built wax pattern tree, ready to be set in a mold
Some like to either take their wax model, or something else entirely and make a silicone mold of it before starting the process. That lets them inject hot wax (a process called injection molding) into the silicone to create the pattern, allowing them to save the original. I’ve never tried the process, but its a great way to make multiple copies of a piece.
Once we have something to replicate in metal, it’s time to make a tree. The tree is a wax structure that holds all of the wax bits we’ve just made, and once wax is burned out of the mold, acts a guide for the molten metal as its poured. The branches of the tree are often referred to as sprues, and the process as spruing. To form the tree, we start with a central wax rod and attach smaller wax wires to it using sticky wax and a wax pen, which heats up wax to melt it. (Man, that’s a lot of wax.) We can then attach the parts we made to those wires. The tree sits in a rubber sprue base, which will form a bowl in the top of the mold called the button. Now that we have a complete pattern, it’s time to make a mold.
Set in Stone… Well, Plaster
We have a positive of our final part, but now we need to make a negative. We’ll take a steel cylinder called a flask and slip it onto the sprue base. We’ll need some investment plaster here too — standard plaster of Paris won’t cut it, as it won’t stand up to the heat. Thankfully, it’s not hard to get your hands on a bag of the the right material. Less thankfully, it’s nasty stuff. I always wear glasses, gloves, and a respirator with I work with it, and work outside for good measure. I even brush my clothes off before going indoors. It turns out that the ingredient that binds the investment, free silica, can cause cancer when inhaled. I’ve found that if something can withstand high temperatures and gives off powder, you probably shouldn’t breathe it. Anyway, we can mix some of that with water and pour it into the flask. I use a handheld electric mixer, which will never see a kitchen again, to mix my investment.
A flask set with investment plaster, and some red sprue wax still visible in the middle of the button
If we just pour it right in, the final piece won’t come out very nice. The mixing process introduces tons of bubbles into the slurry, and thanks to its high viscosity those bubbles aren’t gonna pop themselves. I like to use a vacuum chamber to debubble my investment before pouring it into the flask- don’t let that scare you though.
My “vacuum chamber” is an old mechanical pump plumbed to a Maxwell House coffee can. While the pump is running and the cup of investment is in the coffee can, I violently tap the chamber for a few minutes to help the bubbles make their way to the surface. Another trick I’ve picked up to get rid of bubbles is to wipe isopropyl alcohol onto the pattern and shake off the excess right before pouring the investment. Some like to paint a think layer of investment on and let it harden before mixing up more to pour into the flask. After pouring, I like to put the whole flask into the vacuum chamber to pull out any remaining bubbles, while tapping the chamber a bit more gently. Once we have a flask full of hardened plaster, we should let it to cure fully: at least an hour or two, but I like to wait overnight.
Getting Burned Out
So we’ve made a replica of our final piece, then entombed it in metal and plaster. Now it’s time to destroy all our hard work by throwing it in a furnace. Well, placing it in a kiln. Very carefully. While wearing gloves and safety glasses.
A flask undergoing burnout in a kiln
This part of the process, called burnout, is where we remove the wax/ plastic pattern from the mold. This leaves behind a cavity that, if we’ve done everything correctly so far, is free of ash and ready to accept some molten metal. It’s a bit nerve-wracking, especially if we’ve spent hours carving a wax model.
I like to start the flask out hole-down so that the wax can drip out into a tray as it melts, and then flip the flask hole-up to allow gasses to escape once the melting is complete. Some say to keep it hole-up the entire time. Investment manufacturers have recommended schedules (times and temperatures) to follow, but I like one suggested by
Practical Casting by Tim McCreight
. I listed the schedule I use in the original blog post I linked at the start of this article. We also have some leeway in our choice of kiln here; for my first few tries, I used a lab furnace I stole off of my
brother’s nanofab bench
, returning to it every 15 minutes or so to adjust temperatures to follow the scheduled ramps. Now I use a purpose-built programmable kiln.
The last step in any burnout schedule is to hold the flask at a temperature suitable for casting, generally a few hundred degrees below the pouring temperature of the metal. I usually keep it at 1250 °F until I’m ready to pour.
Melting Some Metal
After all that work we finally have a mold, and now it’s time to fill it. Basically, we’ll melt some metal the pour it into the cavity. We’ll need another furnace for this part- while our kiln is keeping the flask hot, we add metal to a crucible, place it in the furnace, and melt it down. Knowing the pouring temperature of the metal is important here- for example, silver melts at 1,763 °F but pours around 1850 °F. I learned that the hard way when silver which appeared molten in my crucible turned solid in the air between the crucible and the flask while I was trying to pour it. We also need to be careful not to boil the metal, which is actually something that can happen.
Similarly to the previous step, I started out with a furnace stolen from Sam before getting one meant for the task. Both my furnace and kiln are small electric ovens made by TableTop furnaces (in America!). I have links to them in the full equipment list in the blog post I linked to.
Pouring some molten metal (Photo courtesy of Beth Deene)
There are a few ways we can approach the pour. We can take the flask out of the kiln and simply, well, pour the metal. This is known as gravity casting, because we rely on gravity to pull the molten metal down into the mold. It works, but we might see some loss of detail and unfilled crevices where the metal was not able to flow.
Another method is called sling casting, where we put the flask in a holder with a rope tied to it and use our arms to swing the flask in a circle next to us. The centrifugal force helps push metal down into those hard-to-reach spots. I haven’t tried this method, as it terrifies me for obvious reasons.
A slightly more tame version of sling casting is centrifugal casting, where the flask is placed horizontally in a centrifuge, which uses similar action to pull metal into the mold.
My preferred method is vacuum casting. I have a hole in the top of my coffee can vacuum chamber, on which I place a silicone mat (also with a hole through it). The investment plaster is porous, so when I pull a vacuum through the flask, the molten metal is pulled down into the mold.
During the pour, it often doesn’t look like the mold took any metal at all. Instead, it looks like the metal just pooled up in the button rather than flowing through the cavity. This fools me every time, and the pour almost always turns out fine.
Regardless of the method we chose, now we wait a few minutes for the button to cool to a dull red color. At this point, we can quench the flask in a bucket of water. Using tongs, by the way. We’ve been using tongs this whole time. As the water around the flask boils, the investment dissolves and we’ll hear a
thud
as the metal tree falls to the bottom of the bucket. Wait a minute or so for everything to cool, assuming there’s enough water in the bucket: I use 5 gallons. (Less water = more cooling time.) Finally,we can retrieve the tree and hopefully marvel at how well the process went.
Post Processing
We’re done! Well, almost. We have a metal tree, but what we want is metal parts. Unless the parts we cast are tiny trees, in which case I suppose we have a tree of trees. Now we need to do a few post-processing steps to clean up the parts.
A metal tree right out of the quenching bucket (and after some scrubbing)
First up is removing them from the tree. We’ll try to cut the part off of the sprue as close to the part as possible. I use a jeweler’s saw and a small hacksaw for this, but a rotary tool or larger saw should work fine too. Once the parts are separated, we can clean them up. I often grind the remnants of the sprue off with a grinding wheel, and touch up the area with a file. Any bubbles or other defects can be similarly dressed up, then it’s off to a tumbler.
I like to tumble with Dawn dish soap and water in stainless steel shot for several hours to polish up the part. This won’t soften the raw cast texture, so if we want to smooth out any surfaces we’ll need to do that with files and sandpaper ahead of time. The post-processing is an art in itself, so we can expect to spend quite a bit of time in this area, depending on the final look we want to achieve. If the as-cast finish is acceptable then the process goes much quicker.
Well, now we’re actually done. All that’s left is to admire the cool thing we just cast, and make our friends jealous with our newfound hobby.
Waxing Philosophical
I’ve been making things with my hands as long as I can remember, but this process feels different from all the others. There’s something existential about spending hours crafting (or even printing) a wax pattern, only to consume it in the process of forming something new. Most steps of this process are a “point of no return” so everything we do must be deliberate, creating as well as destroying. Any mistakes in the wax pattern are carried through to the final metal piece. There are countless ways for it to go wrong, but it’s the most gratifying process I’ve ever worked with.
Maybe I’m reading too far into the whole thing though. All I can say for sure is that I made some cool stuff, and had a ton of fun along the way. | 24 | 13 | [
{
"comment_id": "6301084",
"author": "CRJEEA",
"timestamp": "2020-12-07T18:37:44",
"content": "Hmm. It begs the question, wax filament. Better yet, liquid filament, with coloured dye injection during extrusion. 3D printed RYB full colour candles? Mixed media prints with “Dissolvable” [ low temperatu... | 1,760,373,262.461528 | ||
https://hackaday.com/2020/12/07/vacuum-tube-logic-hack-chat/ | Vacuum Tube Logic Hack Chat | Dan Maloney | [
"Hackaday Columns"
] | [
"bias",
"boolean",
"digital",
"flip-flop",
"gate",
"Hack Chat",
"logic",
"thermionic emission",
"tube",
"vacuum tube",
"valve"
] | Join us on Wednesday, December 9th at noon Pacific for the
Vacuum Tube Logic Hack Chat
with
David Lovett
!
For most of us, circuits based on vacuum tubes are remnants of a technological history that is rapidly fading from our collective memory. To be sure, there are still applications for thermionic emission, especially in power electronics and specialized switching applications. But by and large, progress has left vacuum tubes in a cloud of silicon dust, leaving mainly audiophiles and antique radio enthusiasts to figure out the hows and whys of plates and grids and filaments.
But vacuum tubes aren’t just for the analog world. Some folks like making tubes do tricks they haven’t had to do in a long, long time, at least since the birth of the computer age. Vacuum tube digital electronics seems like a contradiction in terms, but David Lovett, aka
Usagi Electric
on YouTube, has fallen for it in a big way. His channel is dedicated to working through the analog building blocks of digital logic circuits using tubes almost exclusively. He has come up with unique circuits that don’t require the high bias voltages typically needed, making the circuits easy to work with using equipment likely to be found in any solid-state experimenter’s lab.
David will drop by the Hack Chat to share his enthusiasm for vacuum tube logic and his tips for exploring the sometimes strange world of flying electrons. Join us as we discuss how to set up your own vacuum tube experiments, learn what thermionic emission can teach us about solid-state electronics, and maybe even get a glimpse of what lies ahead in his lab.
Our Hack Chats are live community events in the
Hackaday.io Hack Chat group messaging
. This week we’ll be sitting down on Wednesday, December 9 at 12:00 PM Pacific time. If time zones have you tied up, we have
a handy time zone converter
.
Click that speech bubble to the right, and you’ll be taken directly to the Hack Chat group on Hackaday.io. You don’t have to wait until Wednesday; join whenever you want and you can see what the community is talking about. | 3 | 2 | [
{
"comment_id": "6301101",
"author": "setho",
"timestamp": "2020-12-07T19:13:13",
"content": "Spock beat you to it:https://www.reddit.com/r/audiophile/comments/2xfiaf/mr_spock_and_his_vacuum_tubes/",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6301128",
"... | 1,760,373,262.346724 | ||
https://hackaday.com/2020/12/07/an-epic-quest-for-a-motorized-volume-knob/ | An Epic Quest For A Motorized Volume Knob | Tom Nardi | [
"digital audio hacks",
"home entertainment hacks"
] | [
"28BYJ-48",
"DRV8825",
"logitech",
"Motorized Potentiometer",
"speaker",
"volume control"
] | [Haris Andrianakis] likes his Logitech Z623 sound system. He likes it a lot. Which is why he was willing to hack in his own remote volume control rather than just get a new pair of speakers. But he certainly didn’t make things easy on himself. Rather than trying to tap into the electronics,
he decided to take the long way around and motorize the volume knob
.
The belt drive looked great, but didn’t work.
The idea
seemed
simple enough. Just drill a hole through the PCB behind the knob’s potentiometer, attach some kind of extension to the axle, and turn it with a small servo. Modifying the PCB and potentiometer went well enough, but the trouble came when [Haris] actually tried to turn the thing.
Attaching the servo directly to the axle worked, but it made turning the knob by hand extremely difficult. His next idea was to add a small belt into the mix so there would be some slip in the system. But after designing a 3D printed servo mount and turning custom pulleys on the lathe, it ended up having too much slip, and the knob didn’t always move when the servo turned.
He then swapped out the servo for a small stepper motor. The motor was easy enough to spin when powered down, but didn’t have quite enough torque to turn the knob. He tried with a larger stepper motor that he salvaged from an old printer, but since he could only run it at half the recommended 24 VDC, it too had a tendency to skip steps.
After experimenting with some 3D printed reduction gears, [Haris] finally stumbled upon the 28BYJ-48. This small stepper with an integrated gearbox proved to be the perfect solution, as it had enough muscle to turn the knob while at the same time not restricting its movement when powered down. The rest of the project was relatively easy; with a DRV8825, an ESP8266, and an IR receiver, he’s able to spin the stepper with his TV’s remote. A simple web page running on the ESP8266 even allows him to control volume over the network with his smartphone. Based on similar projects we’ve seen,
he could probably add support for HDMI CEC as well
.
[Haris] says you shouldn’t follow his example, but we’re not so sure. He kept going when others would have given up, and the engineering and thought that went into each attempt is certainly commendable. Even if he hadn’t ultimately gotten this project working, we’d still say it was a valiant hack worthy of praise. | 24 | 9 | [
{
"comment_id": "6301045",
"author": "Pulse width",
"timestamp": "2020-12-07T16:38:25",
"content": "esp8266 and pwm.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6301119",
"author": "DC",
"timestamp": "2020-12-07T19:47:43",
"content... | 1,760,373,262.886004 | ||
https://hackaday.com/2020/12/07/norway-leads-the-charge-to-phase-out-internal-combustion-china-and-the-uk-to-follow/ | Norway Leads The Charge To Phase Out Internal Combustion; China And The UK To Follow | Lewin Day | [
"Current Events",
"Featured",
"green hacks",
"Original Art"
] | [
"china",
"fossil fuel",
"fossil fuels",
"internal combustion",
"internal combustion engine",
"United Kingdom"
] | Climate change promises to cause untold damage across the world if greenhouse gas emissions continue at current levels for much longer. Despite the wealth of evidence indicating impending doom, governments have done what humans do best, and procrastinated on solving the issue.
However, legislatures around the world are beginning to snap into action. With transportation being a major contributor to greenhouse gas emissions —
16% of the global total in 2016
— measures are being taken to reduce this figure. With electric cars now a viable reality, many governments are planning to ban the sale of internal combustion vehicles in the coming decades.
Similar But Different Measures
Norway has seen a huge uptake of cleaner vehicles, which make up over 50% of the market. Image credit: Carlos Bryant
Earlier this year,
we looked at the city of Brussels
, which aims to ban all fossil fuel transport from its city centre by 2035. However, such a heavy-handed measure isn’t necessarily practical worldwide, particularly for those stuck driving older vehicles in areas without strong public transport links. Instead, different states and countries are setting their own timelines on the phase-out of fossil fuel vehicles in an aim to move towards a cleaner transport mix.
One of the fastest-moving is Norway.
With electric and hybrid cars making up over 50% of sales since 2017,
they’re well placed to complete the transition away from internal combustion. EVs alone made up 41% of new car purchases in 2019. The country plans to reach zero sales of fossil fuel vehicles by 2025,
though an outright ban is not yet solidified by law.
Aiming to move somewhat slower but at a far greater scale is China.
Their goal is to sell only hybrids, hydrogen vehicles, and electric vehicles by 2035.
Now the biggest car market in the world,
selling 21.05 million vehicles in 2019,
the policy promises to have a major effect on the automotive industry, both domestically and worldwide. With fossil-fuel only cars facing an outright ban on sales in 2035, carmakers have less incentive than ever to continue investing in internal combustion technology, given it will be shutout from such a large potential market base.
China has historical form where such policies are concerned;
their bans on motorcycles
and then later,
electric bikes
, were executed ruthlessly quickly in past years. However, the vast country does not stand alone in this push. As is common with automotive regulation, large blocs of countries tend to make similar moves at the same time. This eases pressure on automakers who would otherwise have to deal with wildly varying legislation across markets, and by working together, countries can overcome political resistance from automakers who otherwise might have the resources to stifle dissent in a single smaller nation.
After initially setting a target of 2040 for the phase out,
the United Kingdom moved its target up to 2035 and is considering shifting it even sooner to 2030.
California has also set 2035 as a goal for
all new passenger vehicle sales to be zero-emission
, which seems to go so far as to exclude even hybrids. In Canada,
Quebec intends to start their ban in 2035 also
, with British Columbia outlawing new sales by 2040.
A smattering of other European nations are firming up their own plans, too.
Technology To Bridge The Gap
Hydrogen cars like Toyota’s Mirai will not face bans in China, unlike combustion engine vehicles. Image credit: Toyota
China’s policy, and many others, tend to hedge their bets, aiming to reduce transportation emissions over time without betting the farm on electric vehicles entirely. If battery supplies or range figures don’t get to where they need to be in 15 years time, Chinese drivers will still be able to fall back on hybrids or hydrogen cars. This is particularly reassuring for those who regularly drive long distances and worry about getting stranded in electric cars. Additionally, hydrogen cars and hybrids don’t need users to have a home charger to use their vehicle on a regular basis. They can instead be refuelled in much the same manner as a regular gasoline car. This is important for those who live in city apartments, or other areas where street parking is the only option.
Hybrid and hydrogen technologies promise to take the pain out of the switchover to electric vehicles. They can help ease the average driver through the switchover, and provide a useful option for those people who fit a particular edge case that electric vehicles still can’t quite fulfill.
Transition by New Acquisition
Municipalities that ban fossil fuel vehicles can expect improvements to local air quality, though staving off climate change requires these cars to be off the road for good. Image credit: EPA
The vast majority of these bans only affect new vehicle sales. Thus, there will be a lag in actually reducing emissions from transportation, as many drive older vehicles that are years or decades old.
Estimates suggest it can take up to 18 years for 50% of vehicles on the road to comply with a new law.
Thus, it’s unsurprising that most countries have set their targets so far in the future. It will take a long time for the entire second-hand market to switch over to cleaner cars unless outright bans on fossil fuel vehicles come into place. Of course, there’s also the export market to consider; many older vehicles make their way to developing countries. In Uganda, for example,
the average vehicle age is over 16 years
, with many cars stacking on another two decades of driving after that. Shipping older cars out will help clear local pollution and reach targets faster, but if emissions are to be reduced worldwide, fossil fuel cars eventually need to be taken off the road entirely.
Such measures won’t be enough on their own to stave off the pending climate emergency, but are an important part of reducing global emissions output. With transition timetables now up on the board, it’s up to automakers to take the necessary steps to make it happen. Whether this will be a quick and clean switchover, or a drawn out, painful process akin to switching off analog TV will be borne out in due time. | 194 | 33 | [
{
"comment_id": "6301017",
"author": "Martin Matin",
"timestamp": "2020-12-07T15:13:32",
"content": "Exporting oil though …",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6301027",
"author": "Ken",
"timestamp": "2020-12-07T15:41:41",
... | 1,760,373,263.13092 | ||
https://hackaday.com/2020/12/07/slim-rgb-matrix-puts-leds-inside-the-pcb/ | Slim RGB Matrix Puts LEDs Inside The PCB | Danie Conradie | [
"LED Hacks"
] | [
"led matrix",
"neopixel",
"pcb assembly",
"ws2812b"
] | Sometimes all that’s required to build something interesting is to put the same old pieces together differently. [Sayantan Pal] did this for the humble RGB LED matrix, creating an extra-thin version by
recessing WS2812b NeoPixel LEDs inside a PCB
.
The popular WS2812B is 1.6 mm in height, which happens to be the most commonly used PCB thickness. Using
EasyEDA
, [Sayantan] designed a 8×8 matrix with modified WS2812B footprints. A slightly undersized cutout was added to create a friction-fit for the LEDs, and the pads were moved to the back side of the panel just outside the cutout, and their assignment were flipped. The PCB is assembled face down, and all the pads are soldered by hand. Unfortunately this creates rather large solder bridges which slightly increases the overall thickness of the panel, and is probably also unsuitable for production with conventional pick-and-place assembly.
We’ve seen some similar methods with PCB assemblies that use
layered PCBs
. Manufacturers are starting to even
embed components inside multilayer PCBs
. | 16 | 7 | [
{
"comment_id": "6300990",
"author": "eternityforest",
"timestamp": "2020-12-07T13:12:23",
"content": "This should be the new standard for how things are packaged! With cheap four layer boards we don’t need quite as much routing area, and it could be easy enough to socket or hand solder to replace ... | 1,760,373,265.043442 | ||
https://hackaday.com/2020/12/06/ground-off-part-number-leads-to-chip-detective-work/ | Ground Off Part Number Leads To Chip Detective Work | Jenny List | [
"Microcontrollers"
] | [
"8051",
"radio control",
"reverse engineering"
] | Sometimes when a piece of electronics lands on the bench, you find that its chips have their markings sanded off. The manufacturer is trying to make the task of the reverse engineer less easy, thus protecting their market. [Maurizio Butti]
found an unexpected one in an electronic switch
designed for remote control systems, it had the simple job of listening to the PWM signal from a receiver in a model aircraft or similar and opening or closing a FET.
From previous experience he suspected it might be a microcontroller from STC based on the location of power, ground, Rx, and Tx pins.
This 8051-compatible device
could be readily reprogrammed, so he has able to create his own firmware for it.
He’s published the code
and it’s pretty simple, as it simply replicates the original. He acknowledges that this might seem odd, but makes the point that it is left open for future upgrades such as for example repeatedly cycling the output as in a flashing light.
We don’t see so much of the STC chips here aside from
one of their earlier offerings
, but the 8051 core features here more regularly as it’s found in Nordic’s NRF24 series of wireless-capable chips. | 20 | 9 | [
{
"comment_id": "6300741",
"author": "chris Yu",
"timestamp": "2020-12-06T13:54:18",
"content": "As commented by an engineer at work about this practice “it won’t stop a engineer, just slow them down a little”. We were talking about a sample auto speedometer a Chinese firm had sent us (they were g... | 1,760,373,265.102194 | ||
https://hackaday.com/2020/12/06/tiny-chain-link-fence-made-with-hand-cranked-brilliance/ | Tiny Chain-Link Fence Made With Hand-Cranked Brilliance | Danie Conradie | [
"Tool Hacks",
"Toy Hacks"
] | [
"chain link",
"CNC machine",
"lathe",
"machining"
] | Chain link fences are woven with a mechanism that is almost hypnotic to watch, so [Levsha] decided to build his own
tiny hand-crank tabletop version
to make tiny copper wire fences.
Chain link consist of a series of wires bent and woven in a zigzag pattern. The zigzag bends are made by winding the wire around a rotating flat plate inside a stationary tube with a spiral slot in the side to keep the spacing of the bends consistent. [Levsha]’s version is roughly 1/10 scale of the real thing, and only does the bending and winding parts. Linking the bent wire together is up to the operator. All the components were machined on a lathe and CNC router, and beautifully finished and assembled on a wood base. The hardest part was the tube with the spiral slot, which took a few attempts to get right. [Levsha] initially tried to use steel wire, but it was too stiff and caused the winding mechanism to lock up. 0.4 mm copper wire turned out to be the best choice.
Although there is no practical use for this device that we can see, the craftsmanship is excellent, and it is one of those videos that reminds us how badly we want some machine tools.
Fine attention to detail is really what makes videos like this enjoyable to watch. Wee seen a few other such project, like a
beautiful scratch-built lathe
, or a
pneumatic powered drone that can’t fly
. | 24 | 15 | [
{
"comment_id": "6300715",
"author": "Alex Rossie",
"timestamp": "2020-12-06T09:16:18",
"content": "Very cute. I want to try and drive it with one of those demonstration steam engines.Is it a builder thing that otherwise polished and well edited videos don’t start with a demonstration? Seems it woul... | 1,760,373,264.812626 | ||
https://hackaday.com/2020/12/05/diy-automated-roller-blinds/ | DIY Automated Roller Blinds | Rich Hawkes | [
"hardware",
"home hacks"
] | [
"automated blinds",
"esphome",
"homeassistant",
"motor",
"wemos d1 mini"
] | Controlling blinds using off the shelf solutions can be expensive – more so if you have multiple blinds you want to control. [HumanSkunk87] felt the cost was too high, so they designed a controller to
automatically open and close the blinds
.
The main part of this build is a motor and a ball chain gear – a wheel that captures the balls of a ball chain so that the chain can be pulled. The wheel was designed using Fusion3D and then printed out. The motor requires enough power to pull the chain — [HumanSkunk87] figures it needs to be able to pull about 2.5kg in order to raise the blind. After giving up on stepper motors, a DC motor with a worm gear was found to have enough torque to work. A WEMOS D1 Mini controls the motor controller that drives the ball chain wheel. Two micro switches tell the WEMOS when to stop at the bottom and top of the window.
The WEMOS is programmed using ESPHome and it connects to [HumanSkunk87]’s HomeAssistant to complete the automation. Check out the descriptions in the link for the parts and the code used to run everything. There are many other
creative ways to open your blinds
, It’s even possible to
automate curtains instead of blinds
.
View post on imgur.com
[via
reddit
] | 11 | 5 | [
{
"comment_id": "6300717",
"author": "Cyna",
"timestamp": "2020-12-06T09:36:41",
"content": "So he went from a large (NEMA17) stepper without gearing and then decided on a small DC with gearing but without an encoder… But, of course, he also only sticks to premade modules, it seems.",
"parent_id... | 1,760,373,264.747099 | ||
https://hackaday.com/2020/12/05/slot-machine-has-a-handle-on-fun/ | Slot Machine Has A Handle On Fun | Kristina Panos | [
"Arduino Hacks",
"Games"
] | [
"arduino",
"arduino pro mini",
"fruit machine",
"led matrix",
"slot machine"
] | For some reason, when slot machines went digital, they lost their best feature — the handle. Who wants to push a button on a slot machine, anyway? Might as well just play video poker. [John Bradnam] seems to agree, and has built
an open-source three-color matrix slot machine complete with handle
.
In this case, you’ll be losing all of your nickels to an Arduino Pro Mini. The handle is an upgrade to an earlier slot machine project that uses three 8×8 matrices and a custom driver board. When the spring-loaded handle is pulled, it strikes a micro switch to spins the reels and then snaps back into place. Between each pull, the current score is displayed across the matrix. There’s even a piezo buzzer for victory squawks. We only wish the button under the handle were of the clickier variety, just for the feels. Check out the short demo video after the break.
If you’re not a gambler,
you could always turn your slot machine into a clock
. | 2 | 2 | [
{
"comment_id": "6300820",
"author": "Hirudinea",
"timestamp": "2020-12-06T19:11:50",
"content": "The 3D printed handle is interesting, if you made a bunch of them smaller you could make a piano keyboard for a synthizer.",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"commen... | 1,760,373,264.693347 | ||
https://hackaday.com/2020/12/05/hybrid-respirator-uses-repurposed-filters/ | Hybrid Respirator Uses Repurposed Filters | Lewin Day | [
"Medical Hacks"
] | [
"HEPA",
"mask",
"respirator"
] | With the coronavirus raging worldwide, 2020 has seen major shortages of personal protective equipment impact healthcare workers and individuals alike. This has led many to improvise their own solutions.
One of the more complete offerings we’ve seen is this hybrid respirator build from [Ben Howard].
[Ben’s] build goes above and beyond the usual craft project masks. It uses a laser-cut chipboard frame to fit three HEPA filters, originally designed for the Roomba robotic vacuum cleaner. Two are used for exhalation, while one is used for inhalation. A small blower fan is installed with the intake filter, to provide mild positive pressure when breathing in. The assembly is wrapped up in fabric, using layers of spandex, fleece, and ripstop nylon to provide the best possible seal against the wearer’s face.
It’s a build that should appeal to those who want to breathe cleaner air and also protect others from exhaled particles that can spread respiratory viruses. We’ve seen all kind of masks hit the scene this year;
the graphene-impregnated variety is one of the more interesting designs.
Still, one can hope that future years lead to less reliance on such measures! | 15 | 6 | [
{
"comment_id": "6300657",
"author": "theFinn",
"timestamp": "2020-12-06T00:36:53",
"content": "CoolAlso… aww, I didn’t know the dystopian cyberpunk masks we would wear from here on out would be so cute!",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6300687",... | 1,760,373,264.991754 | ||
https://hackaday.com/2020/12/05/a-retro-camcorder-upgraded-as-a-raspberry-pi-hq-camera/ | A Retro Camcorder Upgraded As A Raspberry Pi HQ Camera | Jenny List | [
"digital cameras hacks",
"Raspberry Pi",
"Video Hacks"
] | [
"camcorder",
"raspberry pi",
"Raspberry Pi HQ camera"
] | In 2020 when we carry an all-purpose computer and data terminal able to store our every thought and deed on a global computer network, it’s easy to forget that once upon a time we were excited by the simpler things. Take the camcorder for example, back in the 1990s the idea of a complete video recording solution that captured moving images on tape cartridges and fit in the palm of your hand was a very big deal indeed, and camcorders as we called them in those innocent times were a prized posession. Now they’re a $0.50 find a Goodwill, which is how [Dustin] picked up
the RCA camcoder he’s converting into something altogether more modern
. He’s gutted it and upgraded it by removing the analogue innards and retaining only the case and lens assembly to put around a Raspberry Pi and associated HQ camera module.
Opening the camcorder up reveals a ton of miniaturised analogue circuitry, but once the original assemblies are removed it’s relatively straightforward to put the Pi camera on the rear of the lens unit. There’s plenty of space for the Pi in the box, and he’s putting a touchscreen on the outside.
Sadly the camcorder’s original tiny CRT is no longer working, else that would have been the ultimate retro viewfinder. Still we hope to see some tinkering on that part of the project since
those little CRTS make for delightful hacks
. The project is very much a work in progress, but should serve that these once ubiquitous devices are now in the realm of the throwaway.
This isn’t the first such conversion we’ve seen with a Raspberry Pi,
the original camera module is a handy fit to an 8mm movie camera
. | 14 | 7 | [
{
"comment_id": "6300634",
"author": "Steven Clark",
"timestamp": "2020-12-05T22:00:48",
"content": "Nice trick. Much closer in sensor size than the usual SLR hacks and therefor the lenses have much more practical focal lengths.",
"parent_id": null,
"depth": 1,
"replies": []
},
{
... | 1,760,373,264.864446 | ||
https://hackaday.com/2020/12/05/killing-mosquitoes-with-cardi-b/ | Killing Mosquitoes With Cardi B | Bryan Cockfield | [
"green hacks"
] | [
"555 timer",
"cardi b",
"control",
"floating",
"mosquito",
"music",
"repel"
] | Keeping a bird bath or a pond in your yard is a great way to add ambiance and style, but both of these things can be a haven for mosquitoes. Popular methods of getting rid of them are often with harsh pesticides, but [Shane] has brought us a more
environmentally-friendly way of taking care of these disease-carrying insects by looping a Cardi B playlist underwater
, killing the mosquito larvae.
While the build does include some other favorites such as “Baby Shark” and would probably work with any song (or audio of sufficient volume) the build is still pretty interesting. It’s based on a 555 timer circuit which powered an ultrasonic sound gun, but was repurposed for this build. The ultrasonic modules were replaced with piezo modules which were waterproofed with silicone. The sound produced vibrates at a frequency which resonates with the mosquito larvae and is fatal to them. [Shane] put the build into a small boat which can be floated in any pond, bird bath, horse trough, or water feature.
The major caveat to this build is that it may be damaging to other beneficial animals such as fish or frogs, so he suggests limiting its use to uninhabited stagnant water. Either way, though, it’s a pretty unique way of taking care of a mosquito problem not unlike another build which
takes care of these insects in water a slightly different way
. | 31 | 12 | [
{
"comment_id": "6300574",
"author": "BobH",
"timestamp": "2020-12-05T18:08:03",
"content": "The “boat” looks like what our favorite Asian restaraunt sends Chicken Fried Rice home in :)",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6300575",
"author": "Th... | 1,760,373,264.938251 | ||
https://hackaday.com/2020/12/05/sufficiently-advanced-technology-and-justice/ | Sufficiently Advanced Technology And Justice | Elliot Williams | [
"Hackaday Columns",
"News",
"Rants",
"Slider"
] | [
"ai",
"image enhancement",
"law enforcement",
"neural networks"
] | Imagine that you’re serving on a jury, and you’re given an image taken from a surveillance camera. It looks pretty much like the suspect, but the image has been “enhanced” by an AI from the original. Do you convict? How does this weigh out on the scales of reasonable doubt? Should you demand to see the original?
AI-enhanced, upscaled, or otherwise modified images are tremendously realistic.
But what they’re showing you isn’t reality
. When we wrote about this last week, [Denis Shiryaev], one of the authors of one of the methods we highlighted, weighed in the comments to point out that these modifications aren’t “restorations” of the original. While they might add incredibly fine detail, for instance, they don’t recreate or restore reality. The neural net creates its own reality, out of millions and millions of faces that it’s learned.
And for the purposes of identification, that’s exactly the problem: the facial features of millions of
other people
have been used to increase the resolution. Can you identify the person in the pixelized image? Can you identify that same person in the resulting up-sampling? If the question put before the jury was “is the defendant a former president of the USA?” you’d answer the question differently depending on which image you were presented. And you’d have a misleading level of confidence in your ability to judge the AI-retouched photo. Clearly, informed skepticism on the part of the jury is required.
Unfortunately, we’ve all seen countless examples of “zoom, enhance” in movies and TV shows being successfully used to nab the perps and nail their convictions. We haven’t seen nearly as much detailed analysis of how adversarial neural networks create faces out of a scant handful of pixels. This, combined with the almost magical resolution of the end product, would certainly sway a jury of normal folks. On the other hand, the popularity of intentionally misleading “deep fakes” might help educate the public to the dangers of believing what they see when AI is involved.
This is just one example, but keeping the public interested in and educated on the deep workings and limitations of the technology that’s running our world is more important than ever before, but some of the material is truly hard. How do we separate the science from the magic?
This article is part of the Hackaday.com newsletter, delivered every seven days for each of the last 200+ weeks. It also includes our favorite articles from the last seven days that you can see on
the web version of the newsletter
.
Want this type of article to hit your inbox every Friday morning?
You should sign up
! | 74 | 19 | [
{
"comment_id": "6300557",
"author": "Eric R Mockler",
"timestamp": "2020-12-05T16:25:48",
"content": "“is the defendant a former president of the USA?” LOL",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6300625",
"author": "Mystick",
"timest... | 1,760,373,265.216567 | ||
https://hackaday.com/2020/12/05/arm-and-x86-team-up-in-no-compromise-cyberdeck/ | ARM And X86 Team Up In No Compromise Cyberdeck | Tom Nardi | [
"Cyberdecks"
] | [
"cyberdeck",
"e-ink",
"e-paper",
"Intel NUC",
"led matrix",
"NUC",
"Raspberry Pi 4"
] | Over the last couple of years the cyberdeck community has absolutely exploded. Among those who design and build these truly personal computers there are no hard rules, save perhaps making sure the final result looks as unconventional as possible. But one thing that’s remained fairly consistent is the fact that these machines are almost exclusively powered by the Raspberry Pi. Unfortunately, that means they often leave something to be desired in terms of raw performance.
But [MSG] had a different idea.
His cyberdeck still has the customary Raspberry Pi inside
, but it also has an i7 Intel NUC that can be fired up at the touch of a button. He says it’s the best of both worlds: an energy efficient ARM Linux platform for mobile experimentation, and a powerful x86 Windows box for
playing games
working from home. It’s the hacker equivalent of business in the front, party in the back.
With a KVM connected to the custom Planck 40% mechanical keyboard and seven inch LCD, [MSG] can switch between both systems on the fly. Assuming he’s got the juice anyway; while the Raspberry Pi 4 and LCD is able to run on a pair of 18650 batteries, the cyberdeck needs to be plugged in if he wants to use the power-hungry NUC. If he ditched the Pi he could potentially load up the case with enough batteries to get the Intel box spun up, but that would be getting a little too close to a conventional laptop.
The whole plurality theme doesn’t stop at the computing devices, either. In addition to the primary LCD, there’s also a 2.13 inch e-paper display and a retro-style LED matrix courtesy of a Pimoroni Micro Dot pHAT. With a little Python magic behind the scenes, [MSG] is able to display things like the system temperature, time, and battery percentage even when the LCD is powered down.
In a post on the aptly-named
Cyberdeck Cafe
, [MSG]
talks about how
seeing the VirtuScope built by [bootdsc] inspired him
to start working towards his own personal deck, and where he hopes to take the idea from here. The unique USB expansion bay behind the screen holds particular promise, and it sounds like a few add-on modules are already in the works. But of course, it wouldn’t be a true cyberdeck if it wasn’t
constantly being improved and redesigned
. Come to think of it, that makes at least two rules to live by in this community. | 19 | 10 | [
{
"comment_id": "6300522",
"author": "Thomas Anderson",
"timestamp": "2020-12-05T12:40:31",
"content": "Beauty!",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6300665",
"author": "msg",
"timestamp": "2020-12-06T01:40:20",
"content": "... | 1,760,373,265.393963 | ||
https://hackaday.com/2020/12/05/fans-add-reality-to-virtual-driving/ | Fans Add Reality To Virtual Driving | Al Williams | [
"Arduino Hacks",
"Virtual Reality"
] | [
"driving",
"racing",
"virtual reality"
] | A few decades ago you might have been satisfied with a crude wireframe flight simulator or driving a race car with the WASD keys. Today, gamers expect more realism, and [600,000 milliliters] is no different. At first, he upgraded his race car driving chair and put on VR goggles. But watching the world whiz by in VR is you can’t feel the wind on your face. Armed with a 3D printer, some
software, and some repurposed PC fans
, he can now feel the real wind in virtual reality. You can see the build in the video, below.
The electronics are relatively straightforward and there is already software available. The key, though, is the giant 3D printed ducts that direct the airflow. These are big prints, so probably not for some printers, but printers are getting bigger every day. The fan parts are from Thingiverse, but the enclosures are custom and you can download them from the blog post.
Turns out the cheap motor controllers sometimes are DOA, so it apparently took a few iterations to find one that would drive both motors to 100%. An Arduino works as a bridge between the PC and the fans. How does it work? Looks
windy to us
.
The next project is haptics and
we’ve seen that before
. If you want to build a cockpit on the cheap, check out the
junkyard
. | 16 | 9 | [
{
"comment_id": "6300494",
"author": "BrightBlueJim",
"timestamp": "2020-12-05T09:19:27",
"content": "Now that is slick. What I don’t understand, though, is why the fans have to be steered. Doesn’t the wind always come at you head-on, no matter which way you’re going? It seems like the only time ... | 1,760,373,265.447334 | ||
https://hackaday.com/2020/12/04/sierpinski-pcb-christmas-tree/ | Sierpinski PCB Christmas Tree | Rich Hawkes | [
"LED Hacks"
] | [
"arduino",
"Christmas decoration",
"RGB LED",
"ws2812b-mini"
] | It’s holiday time again! And that means it’s time to break out the soldering iron and the RGB LEDs! If you’re going to make a custom PCB to put those LEDs on, you’ll notice that you get few copies of your PCB in your order, so, might as well design it such that you can combine them all together into a single
Sierpinski Christmas Tree
, just like [Landon Carter] did.
Each PCB “tree” has three connections which can be used as either inputs or outputs by soldering one of two bridge connections on the PCB. The power and signal goes up and down through the tree, rather than across, so the connections go one on the top of the tree and two on the bottom. This way, each tree in the triangle can easily be connected, and each triangle can be easily connected to another. Each individual tree has three WS2812b-mini addressable RGB LEDs and the tree is controlled by an external Arduino.
The first order of 10 PCBs came in, which makes a 9 member tree – next up is a 27 member tree. After that, you’re going to need some pretty high vaulted ceilings in order to put these on the wall. On the upside, though, once the holidays are over, everything can be easily disconnected and packed away with the rest of the decorations. If you, too, are interested in RGB LED decorations, there are a
few
on the
site
for your perusal. | 3 | 2 | [
{
"comment_id": "6300490",
"author": "juergen",
"timestamp": "2020-12-05T08:28:37",
"content": "OK, my options are probably not as beautiful, but anybody can replicate them, with or without computer controlhttps://www.facebook.com/groups/269499491046124Idid them the simple way, but you can make them... | 1,760,373,265.587092 | ||
https://hackaday.com/2020/12/04/the-protein-folding-break-through/ | The Protein Folding Break-Through | Matthew Carlson | [
"chemistry hacks",
"Machine Learning",
"News"
] | [] | Researchers at DeepMind have proudly
announced a major break-through in predicting static folded protein structure
s with a new program known as AlphaFold 2. Protein folding has been an ongoing problem for researchers since 1972. Christian Anfinsen speculated in his Nobel Prize acceptance speech in that year that the three-dimensional structure of a given protein should be algorithm determined by the one-dimensional DNA sequence that describes it. When you hear protein, you might think of muscles and whey powder, but the proteins mentioned here are chains of amino acids that fold into complex shapes. Cells use these proteins for almost everything. Many of the enzymes, antibodies, and hormones inside your body are folded proteins. We’ve discussed
why protein folding is important
as well covered
recent advancements in cryo-electron microscopy used to experimentally determine the structure of folded proteins
.
The shape of proteins largely controls their function, and if we can predict their shape then we get much closer to predicting how they interact. While AlphaFold 2 just predicts the static state, the sheer number of interactions that can change a protein, dynamic protein structures are still out of reach. The technical achievement of DeepMind is not to be understated. For a typical protein, there are an estimated 10^300 different configurations.
Out of the 180 million protein sequences in the Protein database, only 170,000 have had their structures identified. Technologies like the cryo-electron microscope make the process of mapping their structure easier, but it is still complex and tedious to go from sequence to structure. AlphaFold 2 and other folding algorithms are tested against this 170,000 member corpus to determine their accuracy. The previous highest-scoring algorithm of 2016 had a median global distance test (GDT) of 40 (0-100, with 100 being the best) in the most difficult category (free-modeling). In 2018, AlphaFold made waves by pushing that up to the high 50’s. AlphaFold 2 brings that GDT up to 87.
At this point in time, it is hard to determine what sort of effects this will have on the drug industry, healthcare, and society in general. Research has always been done to create the protein, identify what it does, then figure out its structure. AlphaFold 2 represents an avenue towards doing that whole process completely backward. Whether the next goal is to map all the proteins encoded in the human genome or find new, more effective drug treatments, we’re quite excited to see what becomes of this landmark breakthrough. | 22 | 10 | [
{
"comment_id": "6300457",
"author": "Ostracus",
"timestamp": "2020-12-05T03:12:40",
"content": "Folding at home will take on a whole new meaning.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6300469",
"author": "SQ2KTN",
"timestamp": "2020... | 1,760,373,265.648988 | ||
https://hackaday.com/2020/12/04/fm-radio-from-scratch-using-an-arduino/ | FM Radio From Scratch Using An Arduino | Bryan Cockfield | [
"Radio Hacks"
] | [
"amplifier",
"arduino",
"diy",
"fm",
"power supply",
"radio",
"receiver",
"small",
"tuner"
] | Building radio receivers from scratch is still a popular project since it can be done largely with off-the-shelf discrete components and a wire long enough for the bands that the radio will receive. That’s good enough for AM radio, anyway, but
you’ll need to try this DIY FM receiver
if you want to listen to something more culturally relevant.
Receiving frequency-modulated radio waves is typically more difficult than their amplitude-modulated cousins because the circuitry necessary to demodulate an FM signal needs a frequency-to-voltage conversion that isn’t necessary with AM. For this build, [hesam.moshiri] uses a TEA5767 FM chip because of its ability to communicate over I2C. He also integrated a 3W amplifier into this build, and everything is controlled by an Arduino including a small LCD screen which displays the current tuned frequency. With the addition of a small 5V power supply, it’s a tidy and compact build as well.
While the FM receiver in this project wasn’t built from scratch like some AM receivers we’ve seen, it’s still an interesting build because of the small size, I2C capability, and also because all of the circuit schematics are available for all of the components in the build. For those reasons, it could be a great gateway project into
more complex FM builds
. | 50 | 17 | [
{
"comment_id": "6300438",
"author": "CMH62",
"timestamp": "2020-12-05T00:44:23",
"content": "“… something more culturally relevant”?Hmmmmmm",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6300443",
"author": "Hyratel",
"timestamp": "2020-12-0... | 1,760,373,265.877739 | ||
https://hackaday.com/2020/12/04/transforming-work-light-is-more-than-meets-the-eye/ | Transforming Work Light Is More Than Meets The Eye | Tom Nardi | [
"LED Hacks",
"Tool Hacks"
] | [
"modular",
"Pogo pin",
"tool battery",
"work light"
] | While it does use the same M12 batteries, this impeccably engineered work light isn’t an official Milwaukee product.
It’s the latest creation from [Chris Chimienti]
, who’s spent enough time in the garage and under the hood to know a thing or two about what makes a good work light. The modular design not only allows you to add or subtract LED panels as needed, but each section is able to rotate independently so it points exactly where you need it.
Magnets embedded in the 3D printed parts mean the light modules not only firmly attach to one another, but can be stuck to whatever you’re working on. Or you could just stack all the lights up vertically and use the rocket-inspired “landing legs” of the base module keep it vertical. Even if the light gets knocked around, the tension provided by rubber bands attached to each fold-out leg means it will resist falling over. In the video after the break [Chris] says the little nosecone on top is just for fun and you don’t
have
to print it, but we don’t see how you can possibly resist.
The same PCB is used on both ends of the light modules.
Of course, 3D printed parts and magnets don’t self-illuminate. The LED panels and switches are salvaged from cheap lights that [Chris] found locally for a few bucks, and a common voltage regulator board is used to step the 12 volts coming from the Milwaukee battery down to something the LEDs can use. He’s designed a very slick reversible PCB that’s used on either end of each light module to transfer power between them courtesy of semi-circular traces on one side and and matching pogo pins on the other.
As we saw in his recent Dremel 3D20 rebuild
, [Chris] isn’t afraid to go all in during the design phase. The amount of CAD work that went into this project is astounding, and serves as fantastic example of the benefits to be had by designing the whole assembly at once rather than doing it piecemeal. It might take longer early on, but the final results really speak for themselves. | 3 | 3 | [
{
"comment_id": "6300422",
"author": "Gregg Eshelman",
"timestamp": "2020-12-04T22:23:16",
"content": "Those M12 batteries hold quite a bit of power. I have a Milwaukee Pro-PEX expander tool and did all the plumbing connections in a small house with one charge. Only two companies make this tool, the... | 1,760,373,265.692666 | ||
https://hackaday.com/2020/12/04/remoticon-video-how-to-use-machine-learning-with-microcontrollers/ | Remoticon Video: How To Use Machine Learning With Microcontrollers | Mike Szczys | [
"cons",
"Hackaday Columns"
] | [
"AI on the Edge",
"Edge Impulse",
"how-to",
"machine learning",
"neural network",
"stm32",
"tensor flow",
"TinyML"
] | Going from a microcontroller blinking an LED, to one that blinks the LED using voice commands based on a data set that you trained on a neural net work is a “now draw the rest of the owl” problem. Lucky for us, Shawn Hymel walks us through the entire process during
his Tiny ML workshop from the 2020 Hackaday Remoticon
. The video has just now been published and can be viewed below.
This is truly an end-to-end Hello World for getting machine learning up and running on a microcontroller. Shawn covers the process of collecting and preparing the audio samples, training the data set, and getting it all onto the microcontroller. At the end of two hours, he’s able to show the STM32 recognizing and responding to two different spoken words. Along the way he pauses to discuss the context of what’s happening in every step, which will help you go back and expand in those areas later to suit your own project needs.
The hardware used in this demonstration is the STM32 Nucleo-L476RG board, but you can use the same techniques on a wide range of ARM boards and other suitably high-performing chips.
Hardware requirements are spelled out on
the workshop project page
. Shawn has put together
some epic documentation on his GitHub repo
, including slides for the workshop. In the time since the video was recorded, he’s even made
a demo using the Arduino Nano 33 BLE Sense board
which uses a Nordic nRF52480 chip.
The bulk of workshop time is spent working through the labyrinth of software platforms and settings used to train the data set. An interesting demonstration of Jupiter notebooks collects and curates 120 minutes worth of 1-second audio samples for training. There’s another 20 minutes worth of test data — these samples were not present in the training set and will be used verify previously unknown input can be successfully classified.
The training process itself is run on a platform called
Edge Impulse
. This provides a graphical web interface for pulling together the parameters used by the training set. In this case, the audio samples are converted to
Mel-frequency cepstral coefficients
(MFCCs) and fed into a
Keras
neural network. (Late in the workshop Shawn touches on how to tweak the Keras code once you begin to get your feet under you with the entire setup.) The microcontroller will convert each incoming audio sample in real time to an MFCC that can be compared against the dataset spit out as a C package by Edge Impulse.
He makes it look pretty easy, and you should definitely give it a try. At the same time it’s a perfect example of why documenting your project, even if it’s just for personal use, is so important. We’re very happy to have the step-by-step from Shawn, but even he references it when getting into the weeds with importing the data set into the STM32CubeIDE software. | 5 | 3 | [
{
"comment_id": "6300396",
"author": "George",
"timestamp": "2020-12-04T19:56:16",
"content": "Cool! And I was just reading about MFCCs for a project that I need to implement that includes detecting spoken commands…",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id"... | 1,760,373,265.791112 | ||
https://hackaday.com/2020/12/04/circuit-vr-squaring-with-schmitt-triggers/ | Circuit VR: Squaring With Schmitt Triggers | Al Williams | [
"Tool Hacks"
] | [
"falstad",
"schmitt trigger",
"SPICE",
"transistor"
] | In the fantasy world of schematic diagrams, wires have no resistance and square waves have infinitely sharp rise times. The real world, of course, is much crueler. There are many things you can use to help tame the wild analog world into the digital realm. Switches need debouncing, signals need limiting, and you might even need a filter. One of the basic elements you might use is a Schmitt trigger. In
In this installment of
Circuit VR
, I’m looking inside practical circuits by building Schmitt triggers in the Falstad circuit simulator. You can click the links and get to a live simulation of the circuit so you can do your own experiments and virtual measurements.
Why Schmitt Triggers?
You usually use a Schmitt trigger to convert a noisy signal into a clean square digital logic level. Any sort of logic gate has a threshold. For a 5V part, the threshold might be that anything under 2.5V is a zero and at 2.5V or above, the signal counts as a one. Some logic families define other thresholds and may have areas where the signal is undefined, possibly causing unpredictable outputs.
There are myriad problems with the threshold, of course. Two parts might not have exactly the same threshold. The threshold might vary a bit for temperature or other factors. For parts with no forbidden zone, what happens if the voltage is right at the edge of the threshold?
A Schmitt trigger input is a bit different. It has two thresholds. One threshold is how much voltage it takes to trip the input from a zero to a one. The other threshold is how much it takes to trip a one to a zero. For example, if an input starts at 0.3V and starts rising a Schmitt Trigger inverter will see that as a zero and output a one. As the input passes, say 2.5V, the output will shift to a zero because the input is now a 1. So far, this is just like a normal gate. The difference is when the input begins to fall. When the input is at 2.4V, a normal gate would have already flipped the input to the opposite state. The Schmitt trigger, though, will maintain a one until the input crosses the second threshold. Perhaps that’s 2V.
This is very similar to a home thermostat. If your heater is set to warm the house to, say, 70 degrees, it won’t turn on at 69.9 degrees. The temperature will have to fall a bit before the heater will kick on and return the temperature to 70. This is known as hysteresis. Technically, the term refers to the dependence of the state of a system on its history. In order to predict the output of the Schmitt trigger, you need to know both the input voltage and the previous input state. In a way, it is an analog version of a simple state machine.
Here’s a graph showing a signal slowing going up to 5V and then back down to zero. The square trace is the output of a Schmitt trigger inverter with thresholds of 2V and 2.5V. Of course, in real life, the output won’t really be that sharp, but it will be fast and compatible with other logic signals.
In Practice
In practice, you might use a Schmitt trigger to read an RC circuit or clean up the input from a noisy sensor. Driving any sort of capacitive load will interfere with the rise time of a signal and that can lead to problems with digital circuitry, especially if you are dealing with a logic family that has a forbidden region between the high and low thresholds.
Most often, you’ll simply buy an IC to add a Schmitt trigger. That’s usually a package of inverters, but you will find other gate types that have Schmitt trigger inputs. They are also common on certain pins of microcontrollers that expect to connect to noisy signals. You can also create a Schmitt trigger out of op amps, or the
ubiquitous 555 timer IC
. However, for this post, we’ll use good old transistors to get a better sense of what’s happening. As usual, there are several ways to do things, each with their own tradeoffs.
Simulation
To start, consider a
simple inverter with one transistor
. In theory, the transistor is either off so you basically have a 5V pullup resistor to the output, or it is in saturation, so the output is a few tenths of a volt. If you feed a nice square wave into that circuit it will do just fine. But if you send in a noisy sine wave, you’ll get lots of hash at the edges of the output.
The simulation has two possible input sources. If the switch is down, the input will be a voltage you can change with a slider on the right side of the simulation screen. If the switch is up, you’ll get a noisy sine wave. We’ll use that particular input arrangement for all the example circuits.
The scope trace is a bit hard to see, but blown up you can see the edges are very noisy as the transistor switches in and out as the signal goes through the threshold of about 0.7V. This is why we need a Schmitt trigger.
First Take
The Falstad examples have a simple Schmitt trigger, so I borrowed parts of it to come up with
the first attempt
of cleaning up those edges.
That looks much better (although this one does not invert). How does it work? The keys are the feedback from the emitter of Q2 to the emitter of Q1 and the operational modes of the transistors.
If you hover over a transistor in the simulator, it will report if the transistor is in cutoff, saturation, or forward active mode. Just look in the bottom right corner of the simulator while the mouse is over a transistor.
Cutoff is just what it sounds like. The transistor more or less disappears.
Saturation is when the transistor is maxed out on collector current. More base current doesn’t really change anything and the voltage between the collector and emitter will be close to 0V but not quite. In this mode, the transistor acts like a closed switch between collector and emitter.
Forward Active mode is where some amount of base current causes a certain amount of collector current to flow. In theory, the ratio of base current to collector current in this mode is the transistor’s beta, but as long as beta is high, you typically don’t care about it since the circuit doesn’t rely on a specific value of beta. Since beta varies wildly depending on many factors, you usually depend on the voltage through a resistor to set a lower current that you can control precisely.
Three Regimes
These are the three regimes this circuit operates in: Q1 turned off, Q1 saturated, and Q1 in the active region. As a refresher, a transistor turned off will look almost like an open from collector to emitter. In saturation, the transistor will be very close to a short circuit across the emitter and collector. The collector voltage will be just a few tenths of a volt higher than the emitter. In active operation, though, the current in the collector will be proportional to the base current.
If
Q1 is off
, there is more or less a 1/3 voltage divider against 5V to the base of Q2. That’s not exactly right because the base of Q2 adds some resistance, but since it is relatively high you can ignore it. So you get about 1.5V on the base of Q2. That will turn on Q2 bringing the output down to a low voltage. Just as important, the saturated collector current through the 100Ω emitter resistor will keep the emitter node at just under 0.9V.
If you want to verify that, pull the switch down and set the slider to a voltage that cuts Q1 off, say 0V. Because the emitter voltage is at 0.88V, the base of Q1 will need to reach around 1.5V to get Q1 to turn on.
The second regime is when
Q1 is saturated
. It is easy to see that since the collector will have a very low voltage, it will turn Q2 off and the output will just be the pullup resistor to 5V.
If you start increasing the voltage, Q1 will eventually move to the forward active stage. This won’t have much effect on Q2’s voltages, though. There is a slight increase in the emitter voltage which causes a slight increase in output voltage, but that never exceeds 1V.
So things stay mostly the same until Q1 saturates at 1.47V. You may want to edit the voltage source instead of using the slider to get that precise. Also, don’t forget, if you slide past the threshold, you have to reset to zero (or, at least, below the low threshold) before setting the voltage since we are looking for a rise in voltage, not just the arbitrary value.
At 1.46V, Q2’s base is still at 1.5V and the emitter node is still at 880mV. The output is under 1V (984.8mV). At 1.47V input, Q1 saturates and Q2’s base is now under 650mV. The emitter voltage goes to about 815mV.
As input voltage continues to increase, Q2’s base and emitter voltages increase as well and Q2 stays cut off. So what happens if the input voltage drops back to 1.46V? Not much. With Q1 in saturation, it stays in saturation. Note the emitter voltage is now almost 80mV lower than before, so it is easier to keep Q1 in saturation. Since the emitter voltage is dropping with the input, though, you can expect a 40mV drop, roughly, would put things back to the opposite state. At 1.06V, the circuit flips Q1 off again, and you are back to the original state. You can see this summarized in the table below, where 1.46+ means voltage rising to 1.46 and 1.46- means voltage dropping to 1.46.
Input
Q1
Q2
Q2 Base
Ve
Q1 Vbe
Output
0.10+
off
sat
1.531
0.878
-0.778
0.949
1.46+
act
sat
1.531
0.880
0.651
0.809
1.47+
sat
off
0.643
0.815
0.655
5.000
3.00+
sat
off
1.742
2.306
0.694
5.000
1.46-
sat
off
0.637
0.806
0.654
5.000
1.07-
act
act
0.936
0.437
0.633
4.976
1.06-
off
sat
1.531
0.878
0.182
0.949
That’s a bit to process, but if you try entering the table’s input column into the simulator, you’ll see it clearly. Another way to visualize it is to look at a scope trace like the one below. The top trace is the noisy input and the middle is the output. The emitter voltage is the bottom trace. Notice how when the output is low, the bottom trace stays constant but when the output is high, it tracks the input signal. This is what changes the threshold based on the previous state. Notice how the voltage drops before it shoots back up to the off level. Then it drops suddenly to start the next high cycle.
One More Time
The Art of Electronics has a similar Schmitt trigger that uses a direct connection between the two transistors and doesn’t have an explicit voltage divider on Q2. I’ve included it along with the other two circuits in
one simulation
for you to experiment with.
We’ve talked about
Schmitt triggers with opamps
before, but there’s something satisfying about doing it with a few components. If you want a practical application, Schmitts are often in
clocks that read the AC power line frequency
, although you sometimes see a zero-crossing detector doing the same duty. | 6 | 4 | [
{
"comment_id": "6300385",
"author": "jake",
"timestamp": "2020-12-04T19:12:39",
"content": "Big shout out to Paul Falstad and Iain Sharp! I love their simulator! Really helps with explaining to non electrical people.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment... | 1,760,373,265.748417 | ||
https://hackaday.com/2020/12/04/hackaday-podcast-096-diaphragm-engine-diy-dish-washer-forgotten-soviet-computers-and-a-starlink-teardown/ | Hackaday Podcast 096: Diaphragm Engine, DIY Dish Washer, Forgotten Soviet Computers, And A Starlink Teardown | Mike Szczys | [
"Hackaday Columns",
"Podcasts"
] | [
"Hackaday Podcast"
] | Hackaday editors Elliot Williams and Mike Szczys discuss the latest and greatest in geeky goodness. This week we saw a Soviet time capsule come to light with the discovery of a computer lab from a building abandoned in the 1990’s. A two-cycle compressed air engine shatters our expectations of what is involved in RC aircraft design. There’s a new toolkit for wireless hacking on the scene in the form of a revitalized HackRF PortaPack firmware fork. And what goes into dishwasher design? Find out in this exciting episode.
Take a look at the links below if you want to follow along, and as always, tell us what you think about this episode in the comments!
Direct download
(55 MB)
Places to follow Hackaday podcasts:
Google Podcasts
iTunes
Spotify
Stitcher
RSS
Episode 096 Show Notes:
New This Week:
European Right To Repair: Poor Repairability Shamed With Rating System
NSF Releases Video Of Arecibo’s Final Moments
Interesting Hacks of the Week:
Diaphragm Air Engine
Literally Tearing Apart A SpaceX Starlink Antenna
reddit commenter calculates how fast Starlink satellites move in relation to antennas on the ground
Building A Dishwasher From Scratch
HackRF PortaPack Firmware Spoofs All The Things
DEFCON 22: The HackRF PortaPack
Leaking Data Slowly By Switching Ethernet Speeds
TEMPEST: A Tin Foil Hat For Your Electronics And Their Secrets
Urban Explorers Reveal A Treasure Trove Of Soviet Computing Power
Quick Hacks:
Elliot’s Picks:
Building A Vector Graphics Machine From Scratch Including The CRT
Pushing The FPGA Video Player Further
Mouse-Controlled Mouse Controller Is Silly, But Could Be Useful
Mike’s Picks:
MQTT Dashboard Uses SHARP Memory LCD
DIY Camera Motion Rig Is Mostly 3D Printed
Repurposing Large Electronic Price Tags
Can’t-Miss Articles:
“Enhance” Is Now A Thing, But Don’t Believe What You See
Amazon Sidewalk: Should You Be Co-Opted Into A Private Neighbourhood LoRa Network? | 0 | 0 | [] | 1,760,373,265.917886 | ||
https://hackaday.com/2020/12/04/flipbook-automation-saves-your-thumb/ | Flipbook Automation Saves Your Thumb | Al Williams | [
"Arduino Hacks"
] | [
"arduino",
"flipbook",
"zoetrope"
] | You’ve probably seen a flipbook. That’s a book with pictures on each page. Each picture is slightly different than the last one so if you flip rapidly through the book you get a little animation. We like the German word,
Daumenkino
, which translates as “thumb cinema” and that seems appropriate. [Barqunics] put a decidedly new twist on this old technology. His flipbook
senses a viewer and automatically flips the pages
using a motor. You can see the Arduino-controlled device in the video below.
The presence detection is a ubiquitous sonar sensor. The frame is easy to make since it uses cardboard and hot glue. A DC motor like you find on many toy cars or robots provides the rotation. No 3D printing needed, but we did think it would be easy to 3D-print or laser-cut the pieces.
You’d think the flipbook would date back to antiquity, but apparently, the earliest known ones are from the mid-1800s. However, the idea isn’t that different from a
phénakisticope
or a
zoetrope
other than those devices use a disk or drum that would be easy to rotate. Something to consider if you plan to recreate this project.
We should have guessed there would be automated ways to generate images for a flipbook. That opens up a lot of interesting ideas for projects, too. | 3 | 3 | [
{
"comment_id": "6300390",
"author": "Beth",
"timestamp": "2020-12-04T19:41:16",
"content": "I made hand cranked versions of those.https://www.instagram.com/p/CB6s2neB5lB/?igshid=vgursw5whpixhttps://www.instagram.com/p/CB34J9whttn/?igshid=x4cdvkmvhsfphttps://www.instagram.com/p/CB1ETrehhwG/?igshid=1... | 1,760,373,265.959229 | ||
https://hackaday.com/2020/12/04/this-week-in-security-ios-wifi-incantations-ghosts-and-bad-regex/ | This Week In Security: IOS Wifi Incantations, Ghosts, And Bad Regex | Jonathan Bennett | [
"Hackaday Columns",
"News",
"Security Hacks",
"Slider"
] | [
"CVE",
"ios",
"regex",
"This Week in Security"
] | I hope everyone had a wonderful Thanksgiving last week. My household celebrated by welcoming a 4th member to the family. My daughter was born on Wednesday morning, November 25th. And thus explains what I did last week instead of writing the normal Hackaday column. Never fear, we shall catch up today, and cover the news that’s fit to be noticed.
iOS Zero-click Wifi Attack
[Ian Beer] of Google’s Project Zero brings us
the fruit of his lockdown-induced labors, a spectacular iOS attack
. The target of this attack is the kernel code that handles AWDL, an Apple WiFi protocol for adhoc mesh networks between devices. The most notable feature that makes use of AWDL is AirDrop, Apple’s device-to-device file sharing system. Because AWDL is a proprietary protocol, the WiFi hardware can’t do any accelerated processing of packets. A few years back, there was
an attack against Broadcom firmware
that required a second vulnerability to jump from the WiFi chip to the device CPU. Here, because the protocol is all implemented in Apple’s code, no such pivot is necessary.
And as you’ve likely deduced, there was a vulnerability found. AWDL uses Type-Length-Value (TLV) messages for sending management data. For a security researcher, TLVs are particularly interesting because each data type represents a different code path to attack. One of those data types is a list of MAC addresses, with a maximum of 10. The code that handles it allocates a 60 byte buffer, based on that maximum. The problem is that there isn’t a code path to drop incoming TLVs of that type when they exceed 60 bytes. The remainder is written right past the end of the allocated buffer.
There is more fun to be had, getting to a full exploit, but the details are a bit too much to fully dive in to here. It interesting to note that [Ian] ran into a particular problem: His poking at the target code was triggering unexpected kernel panics. He discovered two separate vulnerabilities, both distinct from the vuln he was trying to exploit.
Finally, this exploit requires the target device to have AWDL enabled, and many won’t. But you can use Bluetooth Low Energy advertisements to trick the target device into believing an Airdrop is coming in from a trusted contact. Once the device enables AWDL to verify the request, the attack can proceed. [Ian] reported his findings to Apple way back in 2019, and this vulnerability was patched in March of 2020.
Via
Ars Technica
.
And if a neatly packaged iOS jailbreak is more your speed,
Odyssey
was recently released, a slick looking open source jailbreak app for modern iOS devices. For even more jailbreak goodness, how about jailbreaking your HomePod? The
latest release of Checkra1n
makes it partially possible.
Fortinet Devices Getting Owned
Guess what happens when a serious vulnerability is found and fixed, and system administrators don’t roll out the patches? If you guessed mass exploitation, you’d be correct. CVE-2018-13379 was a directory traversal bug in Fortinet VPN gateways, first found way back in 2018. Just recently,
a dump of plaintext credentials has surfaced on the Internet
— accounts from an eye-watering 49,000+ devices. The whole dump is available in the shadier parts of the internet.
Webex Ghosts
Remember the short-lived panic surrounding unsecured Zoom meetings, and uninvited pranksters connecting to those meetings? It was enough of a moment that “zoombombing” was coined. Well, hold on, because
Webex has just brought us “Ghost Users”
. The research was performed by IBM’s SecurityIntelligence group. They discovered that it was possible to manipulate the join handshake while joining a Webex meeting, and access the meeting without showing up on the list of listeners. The danger here is that a “ghost” could listen in on a confidential meeting. It’s a reminder that there is a new set of challenges in our brave new world. IBM privately reported their findings, and Cisco has patched the vulnerabilities.
Embedded Code Is Vulnerable Too
There is a whole world of proprietary software stacks out there, hidden away in embedded devices, real time controllers, and industrial applications. One of those stacks is the EtherNet/IP (ENIP) networking stack, sold by Real Time Automation (RTA). In a recent post,
Claroty has detailed a pretty serious vulnerability
in that software. One of the functions of ENIP is accepting a forward-open request, part of the Common Industrial Protocol. The validation code for those incoming requests isn’t as robust as it should be, and a too-big request results in memory writes outside the allocated buffer.
The vulnerability is bad enough, potentially allowing device compromise over the network without user interaction. The worst part is that this code is locked away on millions of devices that will likely never receive security updates. This sort of vulnerability is a perfect target for the next Stuxnet style attack against infrastructure somewhere. It’s hard to estimate where all this network stack is hidden, but Claroty found a handful of vulnerable devices directly attached to the Internet, ready to be exploited. RTA has been notified, and has fixed their code, but getting that fix applied on every vulnerable device will take years.
Regex for Security?
XKCD CC BY-NC 2.5
If you find yourself writing code for an application where security matters, and you turn to a regex for validating something, stop and think about the life choices that have led you to this point. There are just too many ways a regex can go wrong, or an unexpected input can match in a way you didn’t anticipate. Case in point, npm package
private-ip
.
John Jackson, AKA [JohnJHacking]
found a Server Side Request Forgery (SSRF) flaw in a server application
, and started digging to find the cause. An SSRF is a fairly simple style of attack, where a request contains forged data, in an attempt to trick the server into connecting to a different IP. In effect, an attacker can request some data, which they have some control over, and have the server send that data to an arbitrary location. Once an attacker has an SSRF, there are a bunch of potential attacks that primitive can be used for, usually involving sending messages to internal-only services.
The actual vulnerability in
private-ip
is an easy one to miss. The package is designed to filter out any requests to private IP addresses, so for example it would block any SSRFs to localhost. So first off,
0.0.0.0
is a special IP address. It acts very similar to
127.0.0.1
, but technically means all listening IPs on the local machine. Private-ip successfully detects a request to
0.0.0.0
, but an attacker could instead make an SSRF request to
0000.0000.0000.0000
. The OS interprets these as the same thing, but the regex code misses the IP address with the extra 0s. Private-ip has released 2.0.0 with a round of fixes and more sane IP matching system. | 8 | 6 | [
{
"comment_id": "6300371",
"author": "Miroslav",
"timestamp": "2020-12-04T17:59:49",
"content": "Congratulations to you and your family! All the best and good luck in life!And thanks for your contributions to HaD.",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": ... | 1,760,373,266.008523 | ||
https://hackaday.com/2020/12/04/nerfnet-tunnels-tcp-ip-over-nrf24l01-radios/ | Nerfnet Tunnels TCP/IP Over NRF24L01 Radios | Tom Nardi | [
"Linux Hacks",
"Wireless Hacks"
] | [
"networking",
"nRF24L01+",
"tunnel",
"wireless communications"
] | There’s an excellent chance you’ve already worked with the nRF24L01. These little modules are an easy and cheap way to shuffle data across a 2.4 GHz radio link at a respectable rate, making them great for remote control projects. But after seeing that others had experimenting with using these radios to transmit digital audio, [Andrew Rossignol] got to wondering if some software trickery could push the envelope even further.
The result is
nerfnet
, a
Linux program that allows you to tunnel TCP/IP over a pair of nRF24L01 modules
. The link appears as a virtual interface, meaning everything happens transparently as far as other programs are concerned. Anything that uses TCP/IP to communicate on Linux can take advantage of this low-cost link, albeit at speeds that most of us haven’t had to deal with in decades.
Though it’s not quite as bad as you might think. Latency is around 50 ms, and after some tweaks, [Andrew] has been able to squeeze almost 300 Kbps out of the link. That’s more than enough for terminal work, and some light audio and video streaming isn’t out of the question.
In terms of range, he was able to maintain a fairly reliable connection at a distance of up to 60 meters (200 feet) outdoors. It might not sound like much, but again, you’ve got to take the cost of these radios into account. If you’re looking to SSH into a Raspberry Pi weather station you’ve got in the backyard, a pair of these could get the job done for just a couple of bucks.
The blog post [Andrew] has put together explains the software in fantastic detail if you’re interested in the nuts and bolts of it all. But if you just want to play around with the idea, you just need to connect some nRF24L01 modules to a pair of Raspberry Pis with short SPI wires to cut down any interference, and follow the instructions.
Ideally the radios would have external antennas
, but it’s not strictly required.
We’ve seen these modules
pushed into service as impromptu Bluetooth Low Energy transmitters
in the past, but nothing quite like this. While the latency and bandwidth offered by this technique might seem antiquated to modern eyes, it could be the perfect dedicated communication channel for your sensors, smart devices, or home automation projects. | 31 | 12 | [
{
"comment_id": "6300254",
"author": "ktol-v",
"timestamp": "2020-12-04T12:17:53",
"content": "“at a distance of up to 60 meters”Wouldn’t that be achievable through a regular WiFi with a half decent antenna?If anything, I would use some 433/868MHz long range LoRa modules – perhaps now that he’s got ... | 1,760,373,266.087807 | ||
https://hackaday.com/2020/12/04/incredible-discrete-mosfet-rover-has-maximum-blink/ | Incredible Discrete MOSFET Rover Has Maximum Blink | Maya Posch | [
"hardware",
"Robots Hacks"
] | [
"cpu1738",
"discrete cpu",
"rover"
] | What do you get when you stick 1738 MOSFETs together? If your answer was a ‘4-bit CPU’, you would be totally correct. Available as a
product over at Marutsu
as the ‘CPU1738’, it seems to target beginners to computer theory, with build instructions that explain how the CPU is built up from individual MOSFETs that are combined into logic gates.
A CPU1738 NAND PCB.
While decidedly more compact in its SMD format than it would have been with pure through-hole parts, the use of countless small PCBs on top of the larger PCBs make for a pretty hefty package. Board after board build up the CPU, and the assembly continues with the addition of sensors, motors, and wheels. In the end, a robot emerges, albeit a somewhat wobbly-looking one.
Check out the video linked after the break, though before starting one up, note
the 50,000 Yen
(approximately $500) price tag for the CPU block alone. On the other hand, in addition to the 1738 MOSFETs, there are also 1070 LEDs, so you get what you pay for in blinkies. | 12 | 6 | [
{
"comment_id": "6300221",
"author": "Andy Pugh",
"timestamp": "2020-12-04T09:49:39",
"content": "Best Christmas Tree Ever.",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6300233",
"author": "oiegw",
"timestamp": "2020-12-04T10:52:38",
"content": "... | 1,760,373,266.15825 | ||
https://hackaday.com/2020/12/03/hardware-keymapper-routes-through-raspberry-pi/ | Hardware Keymapper Routes Through Raspberry Pi | Bryan Cockfield | [
"Raspberry Pi"
] | [
"alt",
"custom",
"keyboard",
"mac",
"mapping",
"raspberry pi",
"remap",
"super",
"windows"
] | There are a lot of keyboards to choose from, and a quick trip through some of the forums will quickly show you how fanatical some people can be about very specific styles or switches. [Crdotson] doesn’t seem to be too far down the rabbit hole in that regard, but he does have a keyboard that he really likes despite one small quirk: it’s built for Mac, and some of the modifier keys aren’t laid out correctly for Windows. Since Windows has limited (and poor) options for software keymapping,
he took an alternative route and built a keymapper in hardware instead
.
The build uses a Raspberry Pi as a go-between from the keyboard to his computer. The Pi watches the USB bus using usbmon, which allows inspection of the packets and can see which keys have been pressed. It then passes those keypresses through to the computer. His only modification to the keyboard mapping is to swap the Alt and Super (Windows) keys for his keyboard of choice, although using this software would allow any other changes to be made as well. Latency is only on the order of a few microseconds, which is not noticeable for normal use cases.
While we have seen plenty of other builds around that can
map keyboards in plenty of custom ways
, if you don’t have the required hardware for a bespoke solution it’s much more likely that there’s a Raspberry Pi laying around that can do the job instead. There are a few issues with the build that [crdotson] is planning to tackle, though, such as unplugging the device while a key is being pressed, which perpetually sends that keystroke to the computer without stopping. But for now it’s a workable solution for his problem. | 19 | 11 | [
{
"comment_id": "6300199",
"author": "Rogan Dawes",
"timestamp": "2020-12-04T08:05:33",
"content": "Looks like a perfect use case for usbproxy (https://github.com/usb-tools/USBProxy-legacy)",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6300227",
"author":... | 1,760,373,266.286847 | ||
https://hackaday.com/2020/12/03/ftdi-vcp-chips-with-custom-pids-not-working-on-macos-11-big-sur/ | FTDI VCP Chips With Custom PIDs Not Working On MacOS 11 Big Sur | Maya Posch | [
"Mac Hacks",
"News"
] | [
"big sur",
"ftdi",
"macOS"
] | An anonymous reader pinged us about an issue that affects people who jumped onto the latest-and-greatest OS from the Apple gardens:
USB devices that stop working due to the FTDI-based USB solution
. At its core appears to be that the built-in FTDI driver provided by Apple (AppleUSBFTDI.dext) only supports FTDI chips which provide the standard FTDI vendor and product ID (e.g. 0x0403 and 0x6001 respectively for the FT232R). Many products however set a custom product ID (PID) to differentiate their device, though in the thread some mention that there are driver issues even with the default VID/PID combination.
Over the past years, Apple has been restricting and changing the way kernel extensions (KExt) and driver extensions (DExt) are handled. As these FTDI chips are often used for virtual com port (VCP) purposes, such as with Arduino boards and USB-TTL adapters, this is a rather cumbersome issue that would affect anyone using Big Sur in combination with such a hardware device.
So far only the FTDI team has been somewhat responsive based on the support forum thread, with Apple seemingly rather silent on the issue. | 49 | 18 | [
{
"comment_id": "6300138",
"author": "Reality Bites",
"timestamp": "2020-12-04T03:16:37",
"content": "What it clearly demonstrates is Apple doesn’t do any testing before releasing.They have adopted the microsoft model of using end users as beta testers.Build a list of what everyone screams about the... | 1,760,373,266.379603 | ||
https://hackaday.com/2020/12/03/pinephone-gets-3d-printed-mechanical-keyboard/ | PinePhone Gets 3D Printed Mechanical Keyboard | Tom Nardi | [
"Peripherals Hacks",
"Phone Hacks"
] | [
"arduino pro micro",
"custom keyboard",
"i2c",
"mechanical keyboard",
"pinephone",
"QMK"
] | Do you remember when smartphones had real physical keyboards? Working the command line on some remote machine over SSH was a breeze, and you could even knock out a few lines of code if you were so inclined. But these days you’ve either got to lug around an external keyboard, or suffer through pecking out a few words per minute on a piece of glass. Doesn’t sound much like progress to us.
By the looks of it, [James Williams] doesn’t think so either. He’s designed a
physical keyboard add-on that snaps onto the back of the PinePhone
to deliver a proper, albeit condensed, typing experience. This is no repurposed BlackBerry board either; he’s created a custom mechanical keyboard that manages to fold into an incredibly small size thanks to resin printed keycaps and Kailh low profile switches. Other than the hand-drawn legends, it’s probably not a stretch to say this is a better keyboard than what many people have on their actual computers.
In addition to the 3D printed frame and Kailh switches, there’s also an Arduino Pro Micro onboard to communicate with the phone. Rather than use USB, the keyboard is
wired to the I2C accessory port on the rear of the PinePhone
. It sounds like [James] needs a little more time to polish his QMK build before its ready to release, so you might want to wait a bit before you start printing off your own copy of the parts.
Those following along with the development of the PinePhone know there’s supposedly an official keyboard accessory in the works, but who wants to wait
when we’re so close to mobile Linux nirvana
? Besides, we doubt it will be nearly as pleasant to type on as the board [James] has put together. | 9 | 4 | [
{
"comment_id": "6300269",
"author": "CampGareth",
"timestamp": "2020-12-04T13:12:11",
"content": "That’d fit nicely with a more desktop-oriented image. Any suggestions? I’m currently on manjaro + phosh but chromium and vscode don’t want to start, I’m guessing manjaro + plasma would stand a better c... | 1,760,373,266.593918 | ||
https://hackaday.com/2020/12/03/nsf-releases-video-of-arecibos-final-moments/ | NSF Releases Video Of Arecibo’s Final Moments | Tom Nardi | [
"News"
] | [
"Arecibo",
"Arecibo Observatory",
"collapse",
"failure",
"investigation"
] | Today the National Science Foundation
released a pair of videos that document the collapse of the Arecibo Observatory
with incredible detail. A wide shot, apparently taken from the Visitors Center, shows the 900 ton instrument platform breaking free and swinging on the remaining support cables until it smashes into the edge of the dish. The second clip, recorded by an airborne drone, is focused directly on the cables as they failed. Both can be seen in the video embedded below.
Together, they produce an invaluable visual record of what finally brought the iconic radio telescope down.
As was predicted by engineers earlier in the month
, the failure of another support cable on tower 4 triggered a chain reaction that brought the entire platform crashing down onto the 305 meter reflector. Footage from a drone observing the top of tower 4 shows that the entire sequence, from the first visual wire break to the remaining cables being torn from their mounts, only took five seconds. While some initially doubted the NSF’s determination that it was too dangerous to repair Arecibo, this footage seems to prove just how tenuous the structural integrity of the Observatory really was.
A drone captured the critical cable failure.
These videos will hopefully help investigators who still need to determine why the cables failed in the first place. The cable in August didn’t snap, it simply pulled lose from its mount. It was suspected that the cable may have been incorrectly installed, but as it was only a backup, the situation was not seen as critical. But when the second cable failed in November
it was found to have snapped at just 60% of its minimum breaking strength
.
This immediately called into question the condition of the remaining cables, and ultimately lead to the decision by the NSF to proceed with a controlled demolition of the Observatory that would preserve as much of the scientific equipment as possible. Unfortunately, the remaining cables didn’t last long enough to put that plan into action.
After the cleanup, investigators will have the opportunity to examine the cables in an effort to find out what caused their premature failure. Was there some design or manufacturing flaw that meant they were always dangerously overrated? Or perhaps investigators will confirm what many already fear; that
humanity has lost a one of a kind scientific instrument
due to
dwindling financial support and lax maintenance procedures
. | 82 | 14 | [
{
"comment_id": "6300052",
"author": "Moryc",
"timestamp": "2020-12-03T21:19:36",
"content": "We can rebuild it. We have the technology.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6300055",
"author": "Jack",
"timestamp": "2020-12-03T21:29... | 1,760,373,266.715609 | ||
https://hackaday.com/2020/12/03/underwater-drone-faces-trial-by-water/ | Underwater Drone Faces Trial By Water | Lewin Day | [
"Misc Hacks"
] | [
"rov",
"rov tether",
"Underwater ROV"
] | Underwater Remote Operated Vehicles, or ROVs as they’re typically known, generally operate by tether. This is due to the poor propagation of radio waves underwater. [Simon] wanted to build such a drone, but elected to go for an alternative design with less strings attached, so to speak. Thus far,
there have been challenges along the way.
(Video, embedded below.)
The underwater drone uses a 3D printed chassis, replete with googly eyes that go a long way to anthropomorphizing the build. Four motors are used for control, with two for thrust in the horizontal plane and two mounted in the vertical plane for attitude control. This allows the drone to be set up at neutral buoyancy, and moved through the water column with thrust rather than complicated ballast mechanisms. The build aims to eschew tethers, instead using a shorter cable to link to a floating unit which uses radio to communicate with the operator on the shore.
The major struggle facing the build has been sealing the chassis against water ingress. This is where the layered nature of 3D printing is a drawback. Even with several treatments of paint and sealant, [Simon] has been unable to stop water getting inside the drone. Further problems concern the excess amount of ballast required to counteract the drone’s natural buoyancy due to displacement.
Regardless of the struggles, we look forward to seeing the next revision rectify some of the shortcomings of the current build.
We’re sure [Simon’s] experience building an electric surfboard will come in handy.
Video after the break. | 7 | 5 | [
{
"comment_id": "6300064",
"author": "jknju",
"timestamp": "2020-12-03T22:06:59",
"content": "If that design is improved, waterproofed enough to be cleaned with Karcher then it could be used to inspect septic tanks.",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id"... | 1,760,373,266.423441 | ||
https://hackaday.com/2020/12/03/remoticon-video-circuit-sculpture-workshop/ | Remoticon Video: Circuit Sculpture Workshop | Kristina Panos | [
"Art",
"cons",
"Hackaday Columns"
] | [
"2020 Hackaday Remoticon",
"brass rod",
"Circuit Sculpture"
] | Circuit Sculpture was one of our most anticipated workshops of Hackaday Remoticon 2020, and now it’s ready for those who missed it to enjoy. A beginning circuit sculptor could hardly ask for more than this workshop, which
highlights three different approaches to building firefly circuit sculptures
and is led by some of the most prominent people to ever bend brass and components to their will — Jiří Praus, Mohit Bhoite, & Kelly Heaton.
For starters, you’ll learn the different tools and techniques that each of them uses to create their sculptures. For instance, Kelly likes to use water-based clay to hold components in specific orientations while forming the sculpture and soldering it all together. Jiří and Mohit on the other hand tend to use tape. The point is that there is no right or wrong way, but to instead have all of these tips and tricks under your belt as you sculpt. And that’s what this workshop is really about.
First up is Mohit, who got into circuit sculpture through BEAM robotics. Mohit likes to give sculptures a personality in the form of color changing and other reactions. Need an easy way to straighten a coil of wire? Mohit chucks it in a drill and after a few turns, it is straight as can be.
Jiri Praus’ take
on the dragonfly sculpture.
Jiří tends to make sculptures that are symmetrical. He often starts with a sketch, and once the idea is realized in 2D will begin to make it 3D. Jiří likes to use 3D printed templates to help bend brass to specific angles or as a jig to create shapes.
Kelly is more of a free-form artist who tends to make organic-looking sculptures. Kelly frequently turns to
Thévenin’s Equivalent
and uses many resistors in series to make a single resistive element that looks complex but is electrically simple.
This workshop is all about mixing and matching the three styles to suit your creative vision, so check it out and have fun.
The firefly template is available on the workshop page
. If you make something,
be sure to post it on Hackaday.io
. | 1 | 1 | [
{
"comment_id": "6300020",
"author": "Phoebe",
"timestamp": "2020-12-03T20:11:50",
"content": "This workshop was incredibly well done! Speakers were interesting and knowledgeable and participating in the activity with my virtual “table” was really fun and engaging. More of this please!",
"parent... | 1,760,373,266.759684 | ||
https://hackaday.com/2020/12/03/crossed-wires-crash-rockets/ | Crossed Wires Crash Rockets | Tom Nardi | [
"Current Events",
"Hackaday Columns",
"Space"
] | [
"Arianespace",
"ESA",
"failure analysis",
"rocketry",
"Vega"
] | On November 17th, a Vega rocket lifted off from French Guiana with its payload of two Earth observation satellites. The booster, coincidentally the 17th Vega to fly, performed perfectly: the solid-propellant rocket engines that make up its first three stages burned in succession. But soon after the fourth stage of the Vega ignited its liquid-fueled RD-843 engine, it became clear that something was very wrong. While telemetry showed the engine was operating as expected, the vehicle’s trajectory and acceleration started to deviate from the expected values.
There was no dramatic moment that would have indicated to the casual observer that the booster had failed. But by the time the mission clock had hit twelve minutes, there was no denying that the vehicle wasn’t going to make its intended orbit. While the live stream hosts continued extolling the virtues of the Vega rocket and the scientific payloads it carried, the screens behind them showed that the mission was doomed.
Displays behind the hosts clearly showed Vega wasn’t following the planned trajectory.
Unfortunately, there’s little room for error when it comes to spaceflight. Despite reaching a peak altitude of roughly 250 kilometers (155 miles), the Vega’s Attitude Vernier Upper Module (AVUM) failed to maintain the velocity and heading necessary to achieve orbit. Eventually the AVUM and the two satellites it carried came crashing back down to Earth, reportedly impacting an uninhabited area not far from where the third stage was expected to fall.
Although we’ve gotten a lot better at it, getting to space remains exceptionally difficult. It’s an inescapable reality that rockets will occasionally fail and their payloads will be lost. Yet the fact that Vega has had two failures in as many years is somewhat troubling, especially since the booster has only flown 17 missions so far. A success rate of 88% isn’t terrible, but it’s certainly on the lower end of the spectrum. For comparison, boosters such as the Soyuz, Falcon 9, and Atlas have success rates of 95% or higher.
Further failures could erode customer trust in the relatively new rocket, which has only been flying since 2012 and is facing stiff competition from commercial launch providers. If Vega is to become the European workhorse that operator Arianespace hopes, figuring out what went wrong on this launch and making sure it never happens again is of the utmost importance.
Mixed Up Vectoring
Within hours, Arianespace and the European Space Agency (ESA) had already launched an investigation into the loss of the vehicle. These investigations often take weeks or even months to come to a conclusion, but in this case, the public didn’t need to wait nearly so long. By the next day,
Arianespace put out a press release explaining that an issue with the thrust vector control (TVC) system of the RD-843
caused the AVUM to go into an uncontrollable tumble roughly eight minutes after liftoff.
Vectoring the Space Shuttle’s RS-25 Engine
In a call with reporters, Arianespace’s Chief Technical Officer Roland Lagier further explained that investigators believe cables connecting two of the TVC actuators was mistakenly swapped during final assembly of the AVUM. The end result is that the motion of the engine’s nozzle was the opposite of what was commanded by the avionics, and that when onboard systems tried to correct the issue, it only made things worse.
He clarified there was no inherent problem with the AVUM or its RD-843 engine, and that this was simply a mistake which hadn’t been caught in time, “This was clearly a production and quality issue, a series of human errors, and not a design one.” The solution therefore would be more stringent post-assembly checks, and likely changes to the cabling that would make it difficult or impossible to repeat the same mistake in the future.
The ESA still needs to verify the findings of Arianespace’s internal investigation, but it’s rumored that close-out images taken of the AVUM during assembly visually confirm the theory actuators were incorrectly wired. While clearly an embarrassing oversight, being able to attribute the failure to human error means that upcoming Vega launches will likely continue as planned.
This Side Up
Readers who may be experiencing a twinge of déjà vu at this point are likely remembering the Russian Proton-M rocket that failed due to very similar circumstances back in 2013. In that case a worker mistakenly installed several angular velocity sensors upside down, providing the booster’s avionics with invalid data. Unprepared for the possibility of such conflicting positional information, the flight control system attempted to correct the situation by commanding the TVC system to make a series of increasingly aggressive maneuvers.
Proton-M rocket disintegrating before impact.
At 23 seconds after liftoff, the Proton-M had completely inverted itself and was pointing downwards. Unfortunately, the flight termination system was designed so that the first stage engines couldn’t be shutdown before 40 seconds into the flight. This feature was in place to help ensure the vehicle had fully cleared the launch complex in the event of an early abort, but in this case, it meant the flight controllers could only watch helplessly as the rocket dove towards the ground at full power.
Investigators examined the debris and confirmed that the angular velocity sensors in question were clearly labeled with arrows that indicated the appropriate installation orientation. Moreover, they were intentionally shaped in such a way that installing them incorrectly was very difficult. In fact, it took so much force to install them improperly that the mounting plate they were attached to was found to have been damaged in the process.
Despite these clear warnings that something was wrong, the junior technician assigned to the task did not alert his superiors to the problem. The mistake also went unnoticed during inspections made by the technician’s supervisor and a quality control specialist, likely due to the fact that the sensors had passed their electrical connectivity tests. The system could detect when sensors hadn’t been wired properly, but it wasn’t designed to verify the data they were producing.
The Human Factor
While we don’t yet know who was responsible for connecting the TVC system of Vega’s AVUM, it wouldn’t come as a surprise to hear it was another junior technician assigned to what was considered a simple task. Unfortunately, there’s no such thing as a simple task when it comes to building an orbital rocket. Equipment worth hundreds of millions of dollars, and potentially even human life, are on the line when the countdown timer hits zero.
Both of these incidents are reminders that when it comes to spaceflight, even the smallest mistakes can have disastrous consequences.
In the wake of the Proton-M failure
, the Russian government had to conduct a full review of the manufacturing and quality control process that went into each rocket that rolled off the assembly line. The ESA will surely want to conduct a similar review of how the Vega is being built, though it’s too early to say what changes and modifications to existing procedures they may recommend.
In the end, the European Space Agency’s response will likely depend on how difficult it ends up being to incorrectly wire the TVC actuators. Only then will they know if Vega was brought down by
a simple accident or gross negligence
. | 69 | 20 | [
{
"comment_id": "6299965",
"author": "X",
"timestamp": "2020-12-03T18:09:25",
"content": "Humans think they are perfect, never make mistakes. Just look at all the hackaday commenters who think that C is a reasonable programming language, thoroughly ignoring the simple fact that humans have been prov... | 1,760,373,266.924931 | ||
https://hackaday.com/2020/12/03/cheap-diy-high-impedance-earphones/ | Cheap DIY High Impedance Earphones | Lewin Day | [
"Radio Hacks"
] | [
"crystal earphone",
"crystal earpiece",
"crystal radio",
"high impedance"
] | Crystal radios can feel magical, given their ability to tune in audio from distant stations with nothing but the energy from the radio signal itself. However, to achieve this feat, they typically rely on a high-impedance earphone to produce an audible sound with very little current. These earphones are hard to find, and thus can be expensive.
However, [Billy] figured out a way to build them on the cheap.
The build starts with a common piezoelectric buzzer. It’s torn down and the extraneous circuitry inside is removed. The piezo element itself is then directly hooked up to a mono audio jack for use with one of [Billy’s] crystal radios. To make it into a usable earpiece, the tip of a pen is cut off and glued to the buzzer’s plastic housing. Then, a rubber in-ear cup from regular modern earbuds is used to ensure a tight, comfortable fit in the ear.
It’s a great way to build something that’s now hard to source, and we bet that [Billy’s] design is more comfortable than the hard plastic models that shipped in Radio Shack kits in the 90s. Of course, there’s other ways to build high-impedance drivers,
as we’ve featured before
. And, if you’re looking to build a crystal radio, it’s hard to go past
[Billy’s] credit card chip build
. Video after the break. | 18 | 7 | [
{
"comment_id": "6299941",
"author": "Paul Hupman",
"timestamp": "2020-12-03T17:00:16",
"content": "I have a couple of those Radio Shack earphones left from kits I had in the 70s. I’ve salvaged and kept a lot of parts over the years but those are likely the oldest.",
"parent_id": null,
"dept... | 1,760,373,266.810609 | ||
https://hackaday.com/2020/12/03/game-cartridges-and-the-technology-to-make-data-last-forever/ | Game Cartridges And The Technology To Make Data Last Forever | Maya Posch | [
"Engineering",
"Featured",
"hardware",
"Original Art",
"Slider"
] | [
"data retention",
"data storage",
"eeprom",
"mask rom",
"mrom",
"PROM"
] | Game cartridges are perhaps the hardiest of all common storage schemes. Short of blunt traumatic force or application of electrical surges to the cartridge’s edge connectors, damaging a game cartridge is hard to do by accident. The same is also true for the data on them, whether one talks about an Atari 2006 cartridge from the late 1970s or a 1990s Nintendo 64 cartridge.
The secret sauce here are mask ROMs (MROM), which are read-only memory chips that literally have the software turned into a hardware memory device. A mask layer unique to each data set is used when metalizing the interconnects during chip fabrication. This means that the data stored on them is as durable as the processor in the game console itself. Yet this is not a technology that we can use in our own hobby projects, and it’s not available for personal long-term data storage due to the costs associated with manufacturing what is essentially a custom chip.
Despite its value as truly persistent storage, MROM has fallen out of favor over the decades. You may be surprised to find a lot of what’s currently used in the consumer market is prone to data corruption over time spans as short as one year to one decade depending on environmental conditions.
So what are we to do if we need to have read-only data that should remain readable for the coming decades?
The Many Flavors of Total Recall
Mask ROM ICs next to a die shot.
The ‘M’ in ROM (Memory) comes in a variety of types; MROM is in the ‘one time programmable’ category along with
PROM
. Some types can be written to repeatedly, such as
EPROM
(where the former requires UV light to erase the contents) and
EEPROM
, where the additional ‘E’ means it can be erased with an electrical current. Magnetic storage is among the easiest to read and (re)write, which is why magnetic tape, floppy discs and hard drives were or are the storage medium of choice in a number of areas.
Finally, there are the ‘blink and it’s gone’ types of memories, such as SRAM and (S)DRAM, which require a constant source of power to keep their data intact.
Which type of memory one chooses depends here largely on the requirements. For system memory, RAM offers low-latency, random access to data, while for long-term storage (beyond a system reboot), magnetic storage has been a favorite destination, with NAND Flash (EEPROM’s sibling) only recently becoming more popular. NAND’s main perk is that it’s faster.
Then there is the data that should survive the life of the system, such as the BIOS and similar essentials that are needed to make the system boot at all. Here EPROMs were common until EEPROM put it out of business a few decades ago. The data retention of a modern EEPROM is rated to be around 10 years, after which it may begin to lose the stored data.
The main reason for data loss in EPROM, EEPROM, Flash and similar
floating-gate MOSFET-based
storage devices is the loss of the stored charge in what are essentially tiny capacitors, either as a factor of time, or due to accumulated damage from writes. This also makes it clear why such storage devices are not ideal for long-term storage.
Solid State Revival
The only known to exist SNES-CD (PlayStation) prototype.
It has often been asked why modern consoles aren’t using cartridges if they are so durable and provide near-zero wait times. The reason for this can be tracked back to the early 90s, when Nintendo and Sony worked on their ill-fated
SNES-CD
project, Sega developed their
Sega CD
add-on, Hudson Soft released its
PC Engine CD-ROM add-on
, and Sony of course went on to launch their first of a range of cartridge-free
PlayStation
consoles. The main advantage of CD-ROMs: roughly 650 MB of space per disc compared to tens of MB per cartridge.
As
Full-Motion Video
and similar features became a distinguishing feature of the console wars of the 1990s, neither the advent of loading screens, nor the joys of swapping between the two or more discs that CD-ROM-based games would often feature, would deter fans or game publishers. Duplicating CD-ROMs was a cheap and easy process, with updates to the software on the disc possible during a production run without excessive costs.
In this regard it’s perhaps ironic that Sony’s PlayStation 5 is now doing its utmost to eliminate the loading times that the use of optical media (currently BluRay) incurs. Over the last few console generations, Sony’s (and Microsoft’s) approach has gone away from playing the game from the disc, using them more like installation discs as a PC would. That way games run from the (much faster) internal hard drive.
Both the PlayStation 5 and Microsoft’s latest cubetastic XBox use NAND Flash-based solid state drives, instead of mechanical hard drives. This allows them to use direct GPU to storage transfers via PCIe (NVMe), a feature which on PC is called ‘
DirectStorage
‘ in DirectX nomenclature and is essentially a kind of
DMA
. Perhaps also ironically, this move towards using DMA to load game resources from solid state media more or less brings those consoles right back to cartridges. Just with extra installation times, from disc or by downloading the software, a step which could be skipped by selling the game on an NVMe-capable card you’d stick into the console when you’d want to play the game.
Nice Data You Got There
It comes as little surprise to anyone that a game cartridge from 1979 still works today in the original game console. After all, we don’t expect ASICs from the 1970s to have magically erased themselves either. Similarly, we expect to be able to play back audio CDs from the 1980s and audio cassettes from the 1960s, but what about burned CD-ROMs from, say, 1998, or those photos you saved on a 128 MB SD card only a few years later?
The quick answer there is ‘it depends’, mostly on the conditions under which the storage device is kept. CD-ROMs are perhaps the most notorious here, with ‘
disc rot
‘ a well-known phenomenon. CD-ROMs also have the data carrying layer on the opposite side of the label, meaning that a scratch on the label will render the disc unreadable. This is a flaw which DVDs fixed, but as optical discs consist of layers that are glued together, they are all susceptible to bit rot and/or delamination.
Basic model of a floating-gate transistor.
NAND Flash
and other types of storage that rely on storing an electrical charge (Floating Gate MOSfet,
FGMOS
) depend on the resistive structures surrounding the charged element to prevent leakage of electrons. Unfortunately a property of FGMOS is that writing (changing the charge) in a cell damages these structures. The shift to higher density NAND Flash in smaller ASIC manufacturing process nodes means smaller structures which damage more easily.
The basic summary here is that the data retention duration of an FGMOS device depends on its initial rated data-retention, minus the number of write cycles, times some device-specific factor. Simply put, the more you write to an FGMOS device, the worse its data retention performance will be, as also alluded to in
this 2017 paper
. This means that the aforementioned 128 MB SD card from twenty years ago might be just fine, since it would use an older, more robust process node. The main question is then how many times was the card written to before it was put aside?
A final consideration for FGMOS devices is the impact of temperature. In 2015 people were shocked to learn that when stored at 30 °C, NAND Flash drives would only be guaranteed to retain their data for about a year, and about a week at 55 °C. Over
at Anandtech
this issue was analyzed in more detail, although this doesn’t take away that leaving an SD card or SSD in a car that’s parked outside or in a loft over the summer is probably not helpful with data retention.
No Easy Answer
Which storage method is right seems to mostly come down to one’s requirements and which way the economics lean at that point in time. For large-scale production, MROM is
still very convenient
as it allows the firmware for a product to be literally added with the rest of the custom ASIC, while guaranteeing that the data will never be modified. PROM is another option here, which requires an additional programming step (blowing efuses or equivalent), but gives otherwise many of the same benefits as MROM.
For embedded applications, high-endurance EEPROM (often called Flash) is commonly used, along with PROM (so-called One-Time Programmable chips). EEPROM would give one at least a decade of guaranteed performance, PROM practically infinite.
Full teardown of Switch cartridge and die shot of ROM.
Meanwhile, Nintendo is apparently using a type of Flash memory called
XtraROM
from Macronix for its Switch
Game Cards
. This XtraROM is
rated for
20 years at 85 °C, with folk
over at the AtariAge forum
speculating about its durability.
Tying these numbers into the earlier referenced AnandTech article on NAND Flash data retention, it would seem that with a bit of luck a Switch cartridge might still work 30-40 years from now, just like the Atari and NES game cartridges we have working today, since they’d presumably be stored at room temperature or something close to it for most of its life. This is assuming that Macronix did their projection correctly, of course.
Over on Mars, NASA’s
Curiosity
rover
has been struggling
with the Flash memory in both its redundant computer cores. Disabling part of this memory resolved the issue initially, but the Curiosity team has been doing remote troubleshooting
as recently as last year
.
Plan For the Persistence You Need
The gist of things seem to be that if you are going to send something into space or to another planet or equally remote, you probably want to put all the essentials such as the operating system and other core files into MROM or PROM. For video game consoles it’s bit harder to say. For using video games right now, today, any storage method is fine, but buying a Switch cartridge in 2040 and finding that its data is corrupt would be somewhat tragic.
Long-term storage on SD cards as I have seen some people do (e.g. taping a microSD card with documentation to a project) might be okay for about a decade at room temperature, unless you’re unlucky. Definitely do not count on the operating system on an SD card stuffed in a hot, industrial environment to make it past a few years.
In the near future
PCM
(as
3D XPoint
) might offer the benefits of both magnetic storage-like write endurance as well as data retention. Yet as a wise person once said: “One copy of a file is no copy.” Basically keep making those backups and no matter how bullet-proof you think that your system is, always add more redundancy than you think you need. | 69 | 35 | [
{
"comment_id": "6299906",
"author": "ngaso",
"timestamp": "2020-12-03T15:12:00",
"content": "What’s with the Total Recall mentions lately? I mean in all the other media.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6299927",
"author": "Ignitron",
... | 1,760,373,267.039926 | ||
https://hackaday.com/2020/12/03/waveshares-pi-cm3-laptop-arrives-a-bit-too-late/ | Waveshare’s Pi CM3 Laptop Arrives A Bit Too Late | Tom Nardi | [
"laptops hacks",
"Raspberry Pi"
] | [
"Compute Module 3",
"gpio",
"laptop",
"Raspberry Pi Compute Module",
"waveshare"
] | The good news it that you can
now buy a pretty decent laptop that’s based around the Raspberry Pi Compute Module (CM)
. The bad news is that it was conceived before anyone knew the interface was going to change for the new CM4, so it doesn’t have any of the features that would make it really interesting such as support for PCI-Express. Oh, and it costs $300.
Waveshare, the company that most of us know best as a purveyor of e-paper displays, also made some rather interesting design choices on their laptop. See that black pad under the keyboard? No, it’s not a trackpad. It’s just a decorative cover that you remove to access an LED matrix and GPIO connectors. Make no mistake, a laptop that features a GPIO breakout right on the front is definitely our jam. But the decision to install it in place of the trackpad, and then cover it with something that looks
exactly
like a trackpad, is honestly just bizarre. It might not be pretty, but
the Pi 400 seemed to have solved this problem
well enough without any confusion.
On the other hand, there seems to be a lot to like about this product. For one, it’s a very sleek machine that doesn’t have the boxy and somewhat juvenile look that seems so common in other commercial Pi laptops. We also like that Waveshare included a proper Ethernet jack, something that’s becoming increasingly rare even on “real” laptops. As [ETA PRIME] points out in the video after the break, the machine also has a crisp IPS display and a surprisingly responsive keyboard. Though the fact that it still has a “Windows” key borders on being offensive considering how much it costs.
But really, the biggest issue with this laptop is when it finally hit the market. If Waveshare had rushed this out when the CM3 was first introduced, it probably would have been a more impressive technical achievement. On the other hand, had they waited a bit longer they would have been able to
design it around the far more capable CM4
. As it stands, the product is stuck awkwardly in the middle.
[Thanks to Sathish for the tip.] | 20 | 10 | [
{
"comment_id": "6299846",
"author": "BrightBlueJim",
"timestamp": "2020-12-03T12:24:12",
"content": "Oh look! It’s the Raspberry Air!",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6299850",
"author": "BrightBlueJim",
"timestamp": "2020-12-03T12:30:2... | 1,760,373,267.101947 | ||
https://hackaday.com/2020/12/03/exhaust-fan-equipped-reflow-oven-cools-pcbs-quickly/ | Exhaust Fan-Equipped Reflow Oven Cools PCBs Quickly | Dan Maloney | [
"Tool Hacks"
] | [
"cooling",
"damper",
"exhaust",
"pid",
"profile",
"reflow",
"smd",
"solder paste",
"soldering"
] | With reflow soldering, sometimes close is good enough. At the end of the day, the home gamer really just needs a hot plate or an old toaster oven and a calibrated Mark I eyeball to get decent results.
This exhaust fan-equipped reflow oven
is an attempt to take control of what’s perhaps the more challenging part of the reflow thermal cycle — the cool down.
No fan of the seat-of-the-pants school of reflow soldering, [Nabil Tewolde] started with a cast-off toaster oven for what was hoped to be a more precise reflow oven. The requisite temperature sensors and solid-state relays were added, along with a Raspberry Pi Zero W and a small LCD display. Adding the cooling assist started by cutting a gaping hole cut in the rear wall of the oven, which was then filled with a short stretch of HVAC duct and a stepper-controlled damper. The far end of the duct was fitted with a PC cooling fan; while it seems sketchy to use a plastic fan to eject hot air from the oven, [Nabil] says the exhaust isn’t really that hot by the time it gets to the fan. At the end of the reflow phase of the thermal profile, the damper opens and the fan kicks on, rapidly cooling the oven’s interior.
Unfortunately, [Nabil] still needs to crack open the oven door to get decent airflow; seems like another damper to admit fresh air would help with that. That would complicate things a bit, but it still wouldn’t be
as over-the-top as some reflow builds
we’ve seen. Then again, that calibrated eyeball thing can work pretty well too, even
without a toaster oven
. | 6 | 3 | [
{
"comment_id": "6299844",
"author": "rpol",
"timestamp": "2020-12-03T12:16:53",
"content": "I’ve been MIL C solder certified, and their process discouraged forced air cooling. Hmm…",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6299920",
"author": ... | 1,760,373,267.146305 | ||
https://hackaday.com/2020/12/02/hot-wire-foam-cutter-does-circles-too/ | Hot Wire Foam Cutter Does Circles, Too | Kristina Panos | [
"Tool Hacks"
] | [
"aluminium tubing",
"diy foam cutter",
"hot wire cutter",
"nichrome wire",
"power regulator"
] | Foam is all kinds of useful, but trying to cut it with scissors or a serrated plastic knife is usually an exercise in futility. What you really need is a hot wire for nice clean cuts.
[Elite Worm] built a hot wire foam cutter that can cut any type of foam with ease, be it Styrofoam or grey craft foam
.
There are a ton of ways to heat up a taut piece of nichrome wire, but few of them are as good looking as this one. [Elite Worm] designed and printed a table with an adjustable fence so it can be used like a table saw. There is also a circle-cutting jig that looks really handy.
This design uses a 12 V power regulator to heat up a piece of tension-adjustable nichrome wire for buttery smooth cuts. This thing looks fantastic all the way down to the cable management scheme.
All the files are available on Thingiverse
if you want to build one for yourself, but you’ll need to use something other than PLA.
This wire cutter is pretty versatile, but
you could go even smaller with a handheld version
, or build
a larger, CNC-based machine
. | 3 | 3 | [
{
"comment_id": "6299832",
"author": "Danjovic",
"timestamp": "2020-12-03T10:17:37",
"content": "Nicely built to the very detail!",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6299843",
"author": "jafinch78",
"timestamp": "2020-12-03T11:54:51",
"c... | 1,760,373,267.238261 | ||
https://hackaday.com/2020/12/02/smart-screen-heal-thyself/ | Smart Screen Heal Thyself | Chris Lott | [
"News",
"Science"
] | [
"folding phone",
"Korea",
"polyimide",
"Screen repair",
"self-repair"
] | The Korea Institute of Science and Technology (KIST)
have announced a transparent, self-healing polyimide material
designed for smart phone screens. A KIST team from the Composite Materials Applications Research Center led by Dr Yong-chae Jung and a team at Yonsei University’s Electronics Materials Lab led by Dr Hak-soo Han collaborated on this project. While the goal was to improve the material used in folding smart phone screens, the results seem applicable to all glass screens that are prone to cracks and scratches.
This new material can heal itself in 12 hours at room temperature, even faster under UV light. As we understand it, many micro-balloons of flaxseed oil are impregnated on the surface and break open if the material is damaged. Thus liberated, the oil is now free to flow into and fill up the cracks. We imagine it’s like repairing windshield cracks, but on a much smaller scale.
The idea is to eliminate the need for user-added screen protection films and increase the life of your phone screen. But cynical people might wonder if smart phone manufacturers will embrace this new technology with much enthusiasm — after all, if people use their phones longer it might cut into sales. Those with access to academic journals can
read the report here
. | 12 | 5 | [
{
"comment_id": "6299754",
"author": "Cyna",
"timestamp": "2020-12-03T03:44:10",
"content": "I understand how the oil flows into a crack, but how does the oil actually help in fusing the two edges?",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6299758",
... | 1,760,373,267.191296 | ||
https://hackaday.com/2020/12/02/fridge-compressor-turned-into-capable-little-four-stroke-engine/ | Fridge Compressor Turned Into Capable Little Four-Stroke Engine | Dan Maloney | [
"Engine Hacks"
] | [
"camshaft",
"carburetor",
"compressor",
"engine",
"exhaust",
"four stroke",
"intake",
"internal combustion"
] | Never underestimate the power of a well-stocked junk bin. Along with a TIG welder and mechanical ingenuity bordering on genius-level, all of which come to bear on
this fridge compressor to four-stroke engine build
.
The video posted by [Let’s Learn Something] is long, but watching it at double speed doesn’t take away much from the enjoyment. By using a piston-type compressor, a lot of the precision machining is already taken care of here. Adding the intake and exhaust valves, camshaft, timing chain, carburetor, and ignition system are still pretty challenging tasks, though. We loved the home-made timing chain sprockets, made with nothing more than a drill and an angle grinder. In a truly inspired moment, flat-head screws are turned into valves, rocker arms are fabricated from bits of scrap, and a bolt becomes a camshaft with built-up TIG filler. Ignition and carburetion are cobbled together from more bits of scrap, resulting in an engine that fired up the first time — and promptly melted the epoxy holding the exhaust header to the cylinder head.
Now, compressor-to-engine conversions aren’t exactly new territory. We’ve seen both
fridge compressors
and
automotive AC compressors
turned into engines before. But most of what we’ve seen has been simple two-stroke engines. We’re really impressed with the skill needed to bring off a four-stroke engine like this, and we feel like we picked up quite a few junk-box tips from this one.
Thanks to [Eric Mockler] for this tip. | 18 | 9 | [
{
"comment_id": "6299729",
"author": "bob",
"timestamp": "2020-12-03T01:23:27",
"content": "big clive did a recent teardown of the clone cdi used in that video. I’d like to see someone build a cdi from scratch because the implementation is terrible and the oem versions are spendy.",
"parent_id":... | 1,760,373,267.292877 | ||
https://hackaday.com/2020/12/01/exploring-turn-of-the-century-raf-avionics/ | Exploring Turn Of The Century RAF Avionics | Tom Nardi | [
"Teardown",
"Transportation Hacks"
] | [
"avionics",
"MIL-STD",
"military",
"military aircraft",
"plasma display",
"teardown"
] | The second hand market is a wonderful thing; you never know what you might find selling for pennies on the dollar simply because it’s a few years behind the curve. You might even be able to scrounge up some electronics pulled out of a military aircraft during its last refit. That seems to be how [Adrian Smith] got his hands on a Control Display Unit (CDU) originally installed in a Royal Air Force AgustaWestland AW101 “Merlin” helicopter. Not content to just toss it up on a shelf, he decided to
take a look inside of the heavy-duty cockpit module and see if he couldn’t make some sense out of how it works
.
Unsurprisingly, [Adrian] wasn’t able to find much information on this device on the public Internet. The military are kind of funny like that. But a close look at the burn-in on the CDU’s orange-on-black plasma display seems to indicate it had something to do with the helicopter’s communication systems. Interestingly, even if the device isn’t strictly functional when outside of the aircraft, it does have a pretty comprehensive self-test and diagnostic system on-board. As you can see in the video after the break, there were several menus and test functions he was able to mess around with once it was powered up on the bench.
With the case cracked open, [Adrian] found three separate PCBs in addition to the display and keyboard panel on the face of the CDU. The first board is likely responsible for communicating with the helicopter’s internal systems, as it features a MIL-STD-1553B interface module, UART chips, and several RS-232/RS-485 transceivers. The second PCB has a 32-bit AMD microcontroller and appears to serve as the keyboard and display controller, possibly also providing the on-board user interface. The last board looks to be the brains of the operation, with a 25 MHz Motorola 68EC020 CPU and 1Mb of flash.
All of the hardware inside the CDU is pretty generic, but that’s probably the point. [Adrian] theorizes that the device serves as something of a generic pilot interface module, and when installed in the Merlin, could take on various functions based on whatever software was loaded onto it. He’s found pictures online that seem to show as many as three identical CDUs in the cockpit, all presumably running a different system.
[Adrian] has uncovered some interesting diagnostic information
being dumped to the CDU’s rear connectors, but he’s still a long way off from actually putting the device to any sort of practical use. If any Hackaday readers have
some inside information on this sort of hardware
, we’re sure like to hear about it. | 25 | 10 | [
{
"comment_id": "6299410",
"author": "Dave",
"timestamp": "2020-12-02T06:15:18",
"content": "haven’t worked on that system but from experience of mil efis systems of that era on the other side of the pond you would need a few more boxes to get it to full action. typical boxes might be a air data com... | 1,760,373,267.456655 | ||
https://hackaday.com/2020/12/01/extracting-a-gate-from-amd-and-intel/ | Extracting A Gate From AMD And Intel | Matthew Carlson | [
"computer hacks"
] | [] | The competition between Intel and AMD has been heating up in the last few years as Intel has released chips fabbed with their 14nm++ process and AMD has been using TMSC’s 7nm process. In the wake of the two semiconductor titans clashing, a debate between the merits of 14nm++ and 7nm has sprung up with some confusion about what those numbers actually measure. Not taking either number at their face value, [der8auer] decided to
extract a transistor from both Intel’s and AMD’s latest offerings
to try and shed some light.
Much of the confusion comes from the switch to the FinFET process. While older planar transistors could be thought of as largely 2d structures, FinFET’s are three dimensional. This means that the whole vertical fin can act as a gate, greatly reducing leakage. It is this fin or gate that [der8auer] is after. On each chip, a thin sliver from the L1 cache was chosen as caches tend to be fairly homogenous sections with transistors that are fairly indicative of the rest of the chip. Starting with a platinum gas intersecting with a focused ion beam on the surface of the chip, [der8auer] built a small deposit of platinum over several hours. This deposit protects the chip when he later cut it at an angle, forming a small lamella 100 micrometers long. In order for the lamella to be properly imaged by the scanning electron microscope, it needed to be even thinner (about 200 to 300nm).
Eventually, [der8auer] was ultimately able to measure the gate height, width, spacing, and other aspects of these two chips. The sheer amount of engineering and analysis that went into this project is remarkable and we love the deep dive into the actual gates that make up the processors we use. If you’re looking for a deep dive into the guts of a processor but perhaps at a more macro scale, why not learn about
a forgotten Intel chip from the 1970s
?
Thanks [paulvdh] for sending this one in! | 16 | 8 | [
{
"comment_id": "6299391",
"author": "Rudranand Sahu",
"timestamp": "2020-12-02T03:47:56",
"content": "This article was way more fascinating than semiconductor fabrication videos.",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6299398",
"author": "Nathan",... | 1,760,373,267.790104 | ||
https://hackaday.com/2020/12/01/watercooling-a-canon-dslr-leads-to-serious-engineering-upgrades/ | Watercooling A Canon DSLR Leads To Serious Engineering Upgrades | Lewin Day | [
"News"
] | [
"camera",
"heatsink",
"water cooling"
] | The Canon EOS R5 is a highly capable, and correspondingly very expensive camera. Capable of recording video in 8K in a compact frame size, it unfortunately suffers from frustrating overheating issues. Always one to try an unconventional solution to a common problem,
[Matt] decided to whip up a watercooling solution
. What ensues is pure, top-notch engineering.
The watercooling setup is amusing, but the real star of the show is the custom copper heatsink that transforms the camera’s performance without spoiling its practicality.
Upon its original release, Canon had the R5 camera simply shut off on a 20 minute timer when recording 8K video. When the userbase complained, an updated firmware was released that used an onboard sensor and would only shutdown when excessive temperatures were reached. Under these conditions, the camera could record for around 25 minutes at 20 °C. [Matt] set about disassembling the camera to investigate, figuring out that the main processor was the primary source of heat. With a poor connection to its heatsink and buried under a power supply PCB, there simply wasn’t anywhere for heat to go, leaving the camera to regularly overheat and take hours to cool down.
After whipping up an amusing but impractical watercooling solution and verifying it allowed the camera to record indefinitely, [Matt] set about some proper thermal engineering. A custom copper heatsink was produced for inside the camera, bonded directly to the processor and DRAM with thermal paste instead of poor-quality thermal tape. This then directs heat out through the plastic back of the camera. In cool environments, this is enough to allow the camera to record continuously. In warmer environments, simply adding a small fan to the back of the camera was enough to keep things operational indefinitely.
[Matt] finishes the video by pointing out that Canon could have made the camera far more useful for videographers by simply investing a little more time into the camera’s cooling design, while also generating more profits by selling a cooling accessory for extended recording. We’ve seen some of [Matt’s] work before too,
such as this DIY 4K projector build
. Video after the break. | 55 | 12 | [
{
"comment_id": "6299359",
"author": "ID",
"timestamp": "2020-12-02T00:12:33",
"content": "This is an awesome hack, prize-worthy.He should sell his design on etsy or ebay. It’ll probably get ripped off eventually, but I bet he could sell a few first.",
"parent_id": null,
"depth": 1,
"re... | 1,760,373,267.727377 | ||
https://hackaday.com/2020/12/01/wemo-smart-plug-gets-brain-transplant/ | Wemo Smart Plug Gets Brain Transplant | Tom Nardi | [
"home hacks",
"Microcontrollers"
] | [
"Belkin WeMo",
"moteino",
"smart home",
"WeMo"
] | Like many modern smart home gadgets, Belkin’s Wemo brand of smart plugs has a tendency to phone home every time you turn on a lamp. [Gigawatts] wasn’t having it, so they figured out how to flash the device with OpenWRT and replicated its original functionality with a web interface. Unfortunately this stopped working after awhile, and rather than trying to diagnose the issue,
it seemed the time would be better spent simplifying the whole thing
.
As [Gigawatts] explains, there are actually two separate boards inside the Wemo plug. One holds the relay to do the high-voltage switching, and the other provides the control. They are linked with a three wire connector, making it exceptionally simple to swap out the original controller for something different. The connector supplies 5 V and ground, all you’ve got to do is pull the third wire high to flick the switch.
While the ESP8266 probably would have been the first choice for many a Hackaday reader, [Gigawatts] actually went with the Moteino, a
low-power Arduino compatible board with integrated RFM69 transceiver
. With an LED to indicate status and a few lines of code tweaked, the Moteino got this once WiFi-only smart plug speaking a new language.
There’s some debate over how effective smart plugs are
from an energy efficiency standpoint, but even if this reborn Wemo doesn’t help [Gigawatts] save much power, at least it won’t be blabbing about everything to a third-party. | 17 | 5 | [
{
"comment_id": "6299333",
"author": "Ronan",
"timestamp": "2020-12-01T21:55:14",
"content": "Using an ESP8266 with Tasmota would simplify the software part.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6299366",
"author": "ForSquirel",
"ti... | 1,760,373,267.511469 | ||
https://hackaday.com/2020/12/01/remoticon-video-how-to-reverse-engineer-a-pcb/ | Remoticon Video: How To Reverse Engineer A PCB | Mike Szczys | [
"cons",
"Hackaday Columns",
"how-to",
"Skills"
] | [
"2020 Hackaday Remoticon",
"pcb",
"printed circuit boards",
"reverse engineering",
"snark barker"
] | You hold in your hand a circuit board from a product you didn’t make. How does the thing work? What a daunting question, but it’s both solvable and approachable if you know what you’re doing. The good news is that Eric Schlaepfer knows exactly what he’s doing and
boiled down the process of reverse engineering printed circuit boards into this excellent workshop
. It was presented live during the 2020 Hackaday Remoticon, and the edited video, which you’ll find below, was just published. Slides for the talk have been published on
the workshop project page
.
Need proof that he has skills that we all want? Last year Eric successfully
reverse-engineered the legendary Sound Blaster audio card
and produced his own fully-functional drop-in replacement called the Snark Barker. And then
re-engineered it to work with the ancient MCA bus architecture
. Whoa.
Eric tackles the challenge in two parts. The first is to generate a bill of materials by harvesting as much information as possible, and then to fill in the rest of the details with liberal use of search engines and datasheets. He pulls everything into a spreadsheet, with columns for the parts designators printed on the board (U1, R53, C4, etc.), package type which you kind of get the hang of with experience, topmark (printed on the parts), and the part number gleaned from the above.
The next step is to reverse engineer the circuit board itself by taking high-resolution images, sometimes removing parts from the board to do so, and a schematic with every part you noted from the first step but no connected traces. Eric demonstrates how to use GIMP image editor to map out traces, adding nets in the schematic as he begins to solve pieces of the puzzle. As he draws the traces on their own layer, switching back and forth between images of the board immediately begins to demystify the connections split between the two layers.
He certainly makes it look both fast and easy, and for him it is. The key is getting a few of these under your belt until you can lean on experience to unstick the sticking points. But whether this is your very first rodeo, or you’re a seasoned veteran, the methodical approach is admirable and a welcomed addition to everyone’s skill set.
As an offhand comment, Eric mentions he could do an hour-long talk just on transformers. Yes please! Eric is known for his deep dives into engineering topics on his Twitter account
@TubeTimeUS
, some of my favorites have been
his unpacking of the Camp Fire grand jury report
which
we reported on in September
, and the story of
how a patent troll brought down Commodore
. He was also on the team of folks that presented
one of the best IC demonstrations
for truly grasping just how silicon makes the world go ’round. | 4 | 4 | [
{
"comment_id": "6299336",
"author": "Carl S",
"timestamp": "2020-12-01T22:15:51",
"content": "This will work a lot of the time.Where you’ll have problems is when the parts are proprietary or unmarked, there are protected programmable parts, there are special calibration procedures, or the PCB has s... | 1,760,373,267.827666 | ||
https://hackaday.com/2020/12/01/spacing-out-rocks-from-the-moon-rocks-from-mars-a-near-miss-and-some-interesting-launches/ | Spacing Out: Rocks From The Moon, Rocks From Mars, A Near Miss, And Some Interesting Launches | Jenny List | [
"Current Events",
"Hackaday Columns",
"Roundup",
"Space"
] | [
"Chang'e 5",
"Kessler syndrome",
"laser downlink",
"mars",
"moon",
"near miss",
"Perseverance",
"RocketLab",
"Spacing Out"
] | Sure,
the SpaceX crew made it safely to the ISS
, but there’s plenty happening beyond just that particular horizon. The Chinese National Space Administration have launched their Chang’e 5 mission to collect and return lunar rock samples, a collaboration between NASA and ESA to do the same with samples from Mars has passed its review, and a pair of satellites came uncomfortably close to each other in a near-miss that could have had significant orbital debris consequences. It’s time for
Spacing Out
!
Bringing Alien Rocks to Earth
The Chang’e 5 mission on the launch pad. China News Service,
CC BY 3.0
.
Ever since the NASA and Soviet lunar launches at the height of the Space Race, there have been no new missions to collect material from the Lunar surface and return it to Earth. That changed last week.
The Chang’e 5 mission launched in China on November 23rd
will deliver moon rocks to earth, and as this is being written it
has already entered Lunar orbit and separated into its constituent parts in preparation for landing
. It’s a four-craft mission, with a lunar lander and ascent module going to the surface, and a service module and Earth return craft remaining in orbit to receive the samples and send them back to the planet for re-entry and retrieval. The hurdles facing the mission scientists and engineers are immense, and a safe sample return in mid-December will be an extremely impressive achievement.
Happily Chang’e 5 even has a hacker angle, as its telemetry has offered a bonanza to satellite-watchers who have turned their dishes skyward to capture the event. Daniel Estévez EA4GPZ has posted
a collected analysis of data telemetry work
by a variety of people worldwide, but the eye-candy prize goes to r00t.cz, who has
successfully decoded image stream data
to the extent that
they have assembled a fragment of video
captured from the craft during its journey.
Not to be outdone in the field of ambitious sample return missions, NASA and ESA’s joint plan to collect and return rock core samples from Mars
has met with the approval of the independent review board
set up to examine it. This will involve multiple craft from both agencies, with NASA’s already launched
Perseverance
rover collecting and containing the samples before leaving them on the surface for eventual collection by a future ESA rover. This will then pass them to a NASA ascent craft which will take them to Martian orbit and rendezvous with an ESA craft that will return them to Earth. We space-watchers are in for an exciting decade.
That Was a Close One!
Anyone who has seen the film
Gravity
will be familiar with the
Kessler syndrome
, in which collisions between spacecraft and or debris could create a chain reaction of further collisions and render entire orbital spheres unusable to future craft because of the collision hazard presented by the resulting cloud of space debris. Because of this, spacecraft operators devote considerable resources towards avoiding such collisions, and it is not uncommon for slight orbital adjustments to be made to avoid proximity with other orbiting man-made objects.
On the 27th of November it seems that these efforts failed, with a terse announcement from Roscosmos of
a near-miss between their
Kanopus-V
craft and the Indian
CARTOSAT 2F
. The two remote-imaging satellites passed as close as 224 metres from each other, which in space terms given their likely closing speeds would have been significantly too close for comfort. The announcement appears worded to suggest that the Indian craft was at fault, however it’s probably a fairer conclusion that both space agencies should have seen the other’s satellite coming. Fortunately we escaped a catastrophe this time, but it is to be hoped that all operators of such satellites will take note.
RocketLab Joins the Reusable Booster Club
Other recent launches that might excite the interest of readers are the New Zealand-based RocketLab launching their Electron rocket with 30 small satellites on board before
for the first time retrieving their booster stage
, and the Japanese Mitsubish Electric sending their
JDRS-1
satellite to geosynchronous orbit. This last craft is of interest because it carries an optical data link rather than the more usual RF, and could prove the technology for future launches.
The coming weeks should be full of news from China on Chang’e 5’s progress. Getting a craft to the moon and returning it will be a huge achievement, and we hope nothing fails and we’ll see pictures of the first new Moon rocks on Earth since the 1970s. We don’t know how to say “Good luck and a successful mission!” in Chinese, so we’ll say it in English. | 4 | 1 | [
{
"comment_id": "6299379",
"author": "Fred",
"timestamp": "2020-12-02T02:12:12",
"content": "I find it interesting that countries who are bitter enemies can co-laborate on orbits, but not all orbits are in the same direction. If all orbits at a certain altitude were, for example, east to west, there... | 1,760,373,267.876676 | ||
https://hackaday.com/2020/12/01/giving-micro-channel-bus-computers-a-sound-blaster-bark/ | Giving Micro Channel Bus Computers A Sound Blaster Bark | Maya Posch | [
"digital audio hacks",
"Musical Hacks",
"Retrocomputing"
] | [
"mca",
"snark barker",
"sound blaster"
] | Not many people today probably remember what ‘Micro Channel Architecture’ was about, though its acronym ‘MCA’ might ring a bell. Created by IBM to replace ISA (Industry Standard Architecture) and presumably claw back some of that sweet, sweet licensing money, it didn’t quite pan out as IBM hoped. As history shows us, PCI ended up replacing MCA in all of IBM’s systems. The IBM PS/2 systems that used MCA didn’t miss out on classic 1990s cards, such as the original Sound Blaster, but today MCA versions of the Sound Blaster are admittedly rather… rare, not to mention expensive.
But, no longer: decades after the last PS/2 users have moved on, [Tube Time] proudly presents the
Snark Barker MCA
. It’s a fully Sound Blaster compatible sound card. It supports AdLib synthesis, digital sound playback and recording, as well as a joystick input and MIDI. Based around a Xilinx XC9572XL CPLD and featuring what looks like a full-length MCA card, it would have made an original Sound Blaster card proud.
The GitHub repository not only contains the schematics, BOM and Verilog-based HDL for the CPLD, but also extensive documentation on the assembly and programming. As a bonus, there’s a troubleshooting section which covers some of the joys that came with the sloppy implementations of MCA across systems. Definitely worth a read.
If anyone decides to build this project and use it in their IBM PS/2 system, we would love to hear about it.
Of course, if all you need is a garden variety PCI Sound Blaster clone,
the original Snark Barker
is the way to go.
(Thanks, Darry) | 15 | 11 | [
{
"comment_id": "6299231",
"author": "Mog",
"timestamp": "2020-12-01T16:42:20",
"content": "I think you mean “…if all you need is a garden-variety ISA Sound Blaster clone”. The one depicted in the final line of the article is decidedly not PCI.",
"parent_id": null,
"depth": 1,
"replies":... | 1,760,373,267.929118 | ||
https://hackaday.com/2020/12/02/european-right-to-repair-poor-repairability-shamed-with-rating-system/ | European Right To Repair: Poor Repairability Shamed With Rating System | Jenny List | [
"News",
"Repair Hacks"
] | [
"eu",
"parliament",
"right to repair"
] | Happily the right to repair movement is slowly gaining ground, and recently
they’ve scored a major success
in the European Parliament
that includes a requirement
that products be labelled with expected lifetime and repairability information, long-term availability of parts, and numerous measures aimed at preventing waste.
… including by requiring improved product information through mandatory labelling on the durability and reparability of a product (expected lifetime, availability of spare parts, etc.), defining durability and reparability as the main characteristics of a product…
Even the UK, whose path is diverging from the EU due to Brexit,
appears to have a moment of harmony on this front
. This builds upon
existing rights to repair
in that devices sold in Europe will eventually have to carry a clearly visible repair score to communicate the ease of repairability and supply of spare parts, making a clear incentive for manufacturers to strive for the highest score possible.
We live in an age in which our machines, appliances, and devices are becoming ever more complex, while at the same time ever more difficult to repair. Our community are the masters of fixing things, but even we are becoming increasingly stumped in the face of the latest flashy kitchen appliance or iDevice. The right to repair movement, and this measure in particular, seeks to improve the ability of all consumers, not just us hackers, to makebuying decisions for better products and lower environmental impact.
With a population of around 450 million people spread across 27 member countries, the EU represents a colossal market that no manufacturer can afford to ignore. Therefore while plenty of other regions of the planet have no such legislation this move will have a knock-on effect across the whole planet. Since the same products are routinely sold worldwide it is to be expected that an improvement in repairability for European markets will propagate also to the rest of the world. So when your next phone has a replaceable battery and easier spares availability, thank the EU-based right to repair campaigners and some European lawmakers for that convenience.
European Parliament from EU,
CC BY 2.0
. | 94 | 20 | [
{
"comment_id": "6299659",
"author": "Andy Pugh",
"timestamp": "2020-12-02T21:51:07",
"content": "I foresee a future for competitive repairing…“Hey, I just fixed the Grade-0 rated Widgetotron 9000”",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6299710",
... | 1,760,373,268.134661 | ||
https://hackaday.com/2020/12/02/templateize-your-timetable-with-epaper-templates/ | Templateize Your Timetable With EPaper Templates | Kerry Scharfglass | [
"hardware",
"Microcontrollers"
] | [
"ambient",
"display",
"e-ink",
"e-paper",
"ESP",
"ESP32",
"status",
"weather",
"web ui"
] | To date, e-paper technology has been great for two things, displaying static black and white text and luring hackers with the promise of a display that is easy on the eyes and runs forever. But poor availability of bare panels has made the second (we would say more important) goal slow to materialize.
One of the first
projects
that comes to mind is using such a display to show ambient information like a daily summary weather, train schedules, and calendar appointments.
Usually
this means
rolling
your own software stack, but [Christopher Mullins] has put together a shockingly complete toolset for designing and updating such
parameterized displays called epaper_templates
.
To get it out of the way first, there is no hardware component to
epaper_templates
. It presupposes you have an ESP32 and a display chosen from a certain list of supported models. A quick search on our favorite import site turned up a wide variety of options for bare panels and prebuilt devices (ESP32 and display, plus other goodies) starting at around $40 USD, so this should be a low threshold to cross.
Once you have the device,
epaper_templates
provides the magic. [
Christopher]’s
key insight is that an ambient display is typically composed of groups of semi-static data displayed in a layout that never changes. The only variation is updates to the data which is fully parameterized: temperature is always integer Fahrenheit, train schedules are lists of minutes and hours, etc. Layouts like this aren’t difficult to make, but require the developer to reimplement lots of boilerplate. To make them easy to generate,
epaper_templates
provides a fully featured web UI to let the user freely customize a layout, then exports it as JSON which the device consumes.
The sample layout configured in the video below
The web UI is shockingly capable, especially for by the standards of the embedded web. (Remember it’s hosted on the ESP32 itself!) The user can place text and configure fonts and styles. Once placed, the text can be set to static strings or tied to variables, and if the string is a timestamp it can be formatted with a standard
strftime
format string.
To round out the feature set, the user can place images and lines to divide the display. Once the display is described, everything becomes simple to programmatically update. The ESP can be configured to subscribe to certain MQTT topics from which it will receive updates, or if that is too much infrastructure there is a handy REST API which accepts JSON objects containing variables or bitmaps to update on device.
We’re totally blown away by the level of functionality in
epaper_templates
! Check out the repo for more detail about its capabilities. For a full demo which walks through configuration of a UI with train arrival times, weather, both instant temperature and forecast with icons, and date/time check out the video after the break. Source for the example is
here
, but be sure to check out
examples/
in the repo for more examples. | 17 | 5 | [
{
"comment_id": "6299693",
"author": "ian 42",
"timestamp": "2020-12-02T22:38:19",
"content": "It does look good – though “temperature is always integer Fahrenheit” should read “temperature is always integer Celsius (accept for Americans)”.",
"parent_id": null,
"depth": 1,
"replies": [
... | 1,760,373,267.984117 | ||
https://hackaday.com/2020/12/02/a-case-for-project-part-numbers/ | A Case For Project Part Numbers | Sonya Vasquez | [
"3d Printer hacks",
"Curated",
"Engineering",
"Featured",
"Slider"
] | [
"3d printer",
"cnc",
"community",
"jubilee",
"open source hardware",
"part numbers"
] | Even when we share the design files for open source hardware, the step between digital files and a real-world mechatronics widget is still a big one. That’s why I set off on a personal vendetta to find ways to make that
transfer
step easier for newcomers to an open source mechantronics project.
Today, I want to spill the beans on one of these finds:
part numbers
, and showcase how they can help you share your project in a way that helps other reproduce it. Think of part numbers as being like version numbers for software, but on real objects.
I’ll showcase an example of putting part numbers to work on one of my projects, and then I’ll finish off by showing just how part numbers offer some powerful community-building aspects to your project.
A Tale Told with Jubilee
To give this idea some teeth, I put it to work on
Jubilee
, my
open source toolchanging machine
. Between October 2019 to November 2020, we’ve slowly grown the number of folks building Jubilees in the world from 1 to more than 50 chatting it up on the Discord server.
@msds’s Jubilee
@h2b’s Jubilee
@EMRosa’s Jubilee
@kurtblah’s Jubilee
@MiasmicTruth’s Jubilee
@Xon’s Jubilee
@grabi’s Jubilee
@Tsunaminaut’s Jubilee
A snippet of the Jubilee fam
These days, Jubilee is still just a collection of
files on the internet
. Folks building one need to meticulously order everything on the bill-of-materials, 3D print all the parts, and then step through the assembly process. The whole process can take a couple months because of the extra wait for parts to ship from overseas. And in that time, the design can get a slight tweak along the way. Here lies a tricky situation for builders. As the project evolves, they need to decide how they want to evolve their build process with it. Do they take the update, or keep building the version they started with? And if they decide to adopt the updates, how do they keep track of how their machine compares against the latest project files?
In software, these might be easy answers. Just check the version of the code you’re running with a simple command line incantation! Or check the name of the file you’re executing, or the date you created it. All of these answers work great for digital files but immediately break down with real world objects. As soon as we transform that STL file into a real world part, we’re losing information. We’re are severing the link between a traceable file with metadata and a physical object it represents. So how do we keep this link? One way, is with a part number inscribed directly into the object itself. That’s the route I took for this project.
Taking a step back, one of my goals with sharing Jubilee is to try to give anyone who builds it a sense of agency over their build process. In short, over time, Jubilee’s design changes as people make it better. And as people build it, I want them to be able to make informed decisions about those changes. To make it happen, I figured it would be useful for folks to be able to identify the machine version they were building by inspecting the actual machine, not the files that created it. That’s the real drive behind part numbers: to give the builder a clear sense of where their machine stands in relationship to the project.
But First: Some Design Theory
If you’ve picked up a copy of Donald Norman’s
The Design of Everyday Things
, the idea of how part numbers can help really starts to make sense. In his book, which
you should totally read
, Norman brings up two distinct concepts,
knowledge in the head
, and
knowledge in the world
. As a user of designed things,
knowledge in the head
is information you need to memorize so that you can use said designed object. It’s whatever matters in the instruction manual.
Knowledge in the world
is also information you need to know so that you can use the object, but it’s somehow attached to the object itself, so you don’t need to memorize it. To hit this idea home, think about plugging some devices into the back of a video projector, like the one below. Which input is which?
with embedded input labels.
without embedded input labels! Which would you rather use?
Thankfully, the one on the top is labeled; that’s
knowledge in the world
. But the one on the bottom is not, it’s in the manual. That’s
knowledge in the head.
Which one would you rather use? While the second one looks cleaner, the first one lets me throw away the instruction manual–or not need one at all! That’s the idea with an inscribed part number. It’s
knowledge in the world
that lets the builder know exactly what they’re holding in their hands in a way that lets them trace it back to the file that created it.
Creating a Part Numbering Scheme
Now that we know how part numbers might help, let’s talk about applying it both to Jubilee and in general. My understanding is that folks in industry fall into two camps when it comes to part numbering schemes. Either (1) your part number is just a number that increments with every new part, or (2) your part number has structured
fields
that each have a specific meaning. An example of the first one is just a sequence of numbers like this:
000001
. And the second might look like this:
07-BED-04-MKS-MRW
.
I think there are places and cases for both; it just depends on the situation. If your part number doesn’t need to be human-readable or can be looked up quickly with a computer, a simple numeric part number makes sense. Heck, you can even encode it on a barcode stickered on the part itself to make the lookup process easier. If the scope of your part numbering scheme is ever-expanding with new categories that you can’t determine up-front, enumeration might also make sense.
But if you’re part number needs some sort of human-readable meaning, the second option might be the way to go. And it was the right fit for Jubilee. First, the project scope is well defined. We know that the machine isn’t going to have an ever-increasing number of categories. Second, and more importantly, people new to the project might need to read the part numbers.
To put together a part numbering scheme, some folks in the Jubilee community kicked off a discussion
on Github
. The plan was to apply the scheme to every non-off-the-shelf-part. Here, that meant every 3D-printed and machined part would get a part number embedded directly onto it. The crux of this conversation was a an open question:
what meaningful information is worth encoding into the part number for other people to read?
We came up with a few takeaways. For all parts, the version mattered, and having some sort of short unique “signature” to easily identify it mattered too. For machined parts, “who made it” mattered.
Besides the conversation on Github, other situations on Jubilee’s Discord server were motivating the push to identify parts, namely debugging other builders’ setups. For one, mixing parts from different versions of the machine didn’t always work, so builders with mixed batches of parts would find themselves in scenarios where the assembly instructions asked them to do something impossible.
In other cases, some folks arrived with machined parts whose manufacturing quality was causing assembly or performance issues. But without knowing where those machined parts came from or how they were made, it would take extra conversation to uncover whether any of the machining processes were responsible for the issues. In a nutshell, having any form of
traceability
up front would be an added bonus to shortcut a few steps in debugging someone else’s Jubilee setup.
After some back and forth, I settled on a scheme that looked like this:
[subassembly] – [part id + params] – [revision] – [fab process + material] – [who fabricated it]
with a shortened version that looked like this:
[part id + params] – [revision]
The first option was the full part number. The second was the bare minimum that needed to fit on the part somewhere. Most 3D printed parts just embed the short part number which is inset on the side of the part. Here’s a shot of what these look like in action on a handful of parts.
Finally, I should mention that part numbers for Jubilee are project-specific. A different project means a different set of part numbers (although I might reuse
the same scheme
). But in this situation, we just need a way to help Jubilee builders know what they’re building from, and communicate with each other in a way that’s highly specific.
Parts Made with Decentralized Manufacturing
As Jubilee’s design matured, a few machinists actually started to make small batches of parts to sell them to the growing community of builders. The result was that the design became easier to self-source since you could just buy machined parts if you couldn’t make them yourself.
With the part numbering scheme set, I reached out to these machinists asking if they’d be willing to etch part numbers on their parts and list the part number on their website. They kindly agreed. Here, each vendor gets a unique part number that’s similar except for the last few fields. Those last sections identify the part’s material and manufacturer.
The Spec
a 713Maker Bed
A Mandala Rose Works Bed
So while both
713Maker
and
Mandala Rose Works
both make aluminum bed plates, the part numbers can tell a story about what they’re made from and who made them. Second off, having a part number also serves as a “qualifier” to the new Jubilee builder. It’s an implicit promise that the parts made from these places have enough community support to merit some recognition in the form of some project identification. Finally, if any of these parts cause issues, any builder in the community can use the part number to reach out to the machinist who made the part to ask for support. This is true even if they didn’t build the machine themselves and bought one already assembled from someone else.
Printed Part Number Legibility
As far as print settings go, I found that printed part numbers were easiest to read when the text was printed on the side walls of the part. This spot makes part numbers legible even if they’re only 25 layer lines thick.
Furthermore, printing on this side seems to be fairly legible across most types of 3D printers–even budget machines like the Ender 3 Pro. While I definitely tried to print the numbers on the tops and bottoms of 3D printed parts, the small letter features simply don’t come out consistently and make the part that much harder to print across a range of machines.
Designing with Part Numbers
These days, every time I modify a part between
GitHub Releases
, I’ll update the part number. In practice, this is pretty easy to track. If I’m editing a part between a release, I just tick the number and re-export the STL in the preferred print orientation. The part number is stored as metadata in the model file, but if I get confused about what number I’m counting from, I can just lookup the STL from the last release. What that means is that
STL files keep their names
, but their contents change. This saves us from extra bookkeeping since part hyperlinks in places like the
wiki
don’t need to change every time the part number changes. This is also in-line with software practices. Every time we change a file, we don’t give it a new name. Version control software tracks the file’s history for us. And the same is true for design files that represent hardware if you track them with a tool like Git. Fun fact! GitHub will actually
render a diff of two STL files
from your commits if you dig for them.
Github’s representation of this part’s changes between the last two commits.
Any time I change I part between a release, I’ll also make a note in the project’s
Changelog
. When a Jubilee builder encounters a new release, they can find a quick listing of all the non-stock parts that changed in some way. This is also the place to get a summary about what geometry changed on that part and why. That way they can decide for themselves if upgrading to the new part is worth the effort of reassembling part of their machine.
Communicating with Part Numbers
Remember that one part in the assembly instructions? It was that
flibbity-jibbit-short-left-hand-edition–version-3
?
Naming things is hard. Describing them is harder. With inscribed part numbers, communicating about the design becomes much easier. It’s easier between project builders
and
between builders and designers. There are two reasons for this. First, we don’t need to lookup any part names; they’re written directly on the parts themselves! That’s extremely useful when we want to have a conversation about these parts. Second, the name is highly specific and unique to that version of that part. By referring to the part with the part number, there’s no ambiguity to what we’re talking about.
The result is that some hiccups in communication just “go away.” If someone wants to talk about parts in the assembly process, they don’t have to struggle to describe them or look up their names; they just inspect them for their numbers. Second, if someone is building with versions of parts that are incompatible, we can catch it by cross-referencing them against the Changelog. And when your Discord community is over 1,000 people of various skill levels asking for help building different machine versions, eliminating any friction in communication is key to having an easier debugging experience.
Finally, what’s really special is that the part numbers are so specific that builders who aren’t the original project designers can have a conversation without needing clarification from the designer about the differences between the parts between them. That’s powerful. Adding part numbers removes the need from the designer to serve as mediator to clarify design details. The design works directly
with
the community instead of having it distilled from the original designer.
Part Numbers Build Community, Partly
I admit: coming up with a numbering scheme and then implementing it partway through the project was a ton of extra effort. So here’s a good question: if the machine already works for you, why go through so much extra effort to add something to the project that doesn’t directly enhance your machine? I think the answer comes down to sharing.
Speaking honestly, I don’t know how popular tool-changing machines will be in the future. But I know that designing them is hard. And, at the end of the day, I really want to see people build fun applications on top of them. But not everyone who comes to the table excited to play with them will have the time or skills to design one. So the question I try to ask myself now is:
how can I take you with me?
I think part numbers are one way of doing that. They’re a way to give the whole crew of people building your project a common language to help answer questions from the new folks. They’re a way to help them identify whether a machine has issues that are design-related or related to modifications it received by its builder. And while I can’t keep up with every question new builders ask–the community can! And equipping them with a precise language is partly how we make them more capable of sustaining growth. And with more voices able to answer your build questions, you too can get yourself a working machine. So even if you can’t or don’t want to design up a nice toolchanging platform from scratch, you can still build on top of it.
I wish I could take credit for part numbers, but I can’t. Engineering teams in industry use them all the time to share and delegate complexity on big projects. What’s to stop us open source hardware hackers from borrowing some of their methods to build community?
Great–Where Do I Learn More?
And hey, don’t take my word for it. A few folks suggested part numbers to me back in the early days of Jubilee’s release. Eventually, this video also landed on the Discord server, and it really hit the argument home. Let Wintergatan take you through a fun discussion on his mission wrangling with the complexity of his machine. | 32 | 19 | [
{
"comment_id": "6299573",
"author": "bluecat57",
"timestamp": "2020-12-02T18:32:04",
"content": "GMTA but unfortunately not many appreciate logic and documentation.",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6299580",
"author": "Max S.",
"timestam... | 1,760,373,268.225214 | ||
https://hackaday.com/2020/12/02/clone-console-cribs-ben-hecks-classic-snes-cache/ | Clone Console Cribs Ben Heck’s Classic SNES Caché | Drew Littrell | [
"Games",
"Teardown"
] | [
"ben heck",
"clone",
"teardown",
"videogames"
] | “I don’t get mad when people rip me off. I actually think its kinda cool, because imitation is the sincerest form of flattery.” — Ben Heckendorn
For some “hacking things together” can mean heavily borrowing from other’s work in order to make a new, derivative work. Though longtime hardware hacker, Ben Heckendorn, didn’t expect one of his early SNES handheld projects to become the inspiration for a Famicom-style clone console. There have been a number of clone consoles available online for years, and all have been made to varying levels of build quality. The subject clone console in question is called the Easegmer 12-bit Retro Console, so [Ben] decided to
record his teardown of the handheld borrowing from his original design.
(Video, embedded below.)
The Easegmer handheld has a “surprising” list of features according to its packaging including: sports games, logic games, memoyr games, USB charger management, double power supply option, and dirunal double backlight option. All big (and slightly misspelled) promises though the most egregious claim has to be that, “No violent games, your child’s body and mind get full exercise.”. The statement may have a modicum of truth to it,
except for the fact that game 84 of 220 is literally named “Violent”
. Dunking aside, the handheld does feature a standard size rechargeable battery in addition to the option of powering the device with three AAA batteries. There’s even a “fun size” screwdriver and a few replacement screws included which is more than you can say for most modern electronics.
It has been almost twenty years after [Ben] originally
published his SNES portable project on his website
. So as a long awaited follow-up, [Ben] plans to make a “meta-portable”. This meta portable will start with the Adobe Illustrator files he kept from that SNES portable in 2001 and incorporate pieces of the Easegmer clone console. Thus spawning a new clone of the clone of his clone…or whatever that project ends up being its sure to be worth repeating. | 2 | 1 | [
{
"comment_id": "6299557",
"author": "Blamoo",
"timestamp": "2020-12-02T17:32:48",
"content": "At least he got ripped off by a pretty competent chinese weirdo… I mean, the thing has heat set inserts and even some quality-related details that are often cut off to reduce production costs…",
"paren... | 1,760,373,268.266262 | ||
https://hackaday.com/2020/12/02/the-dark-side-of-solar-power/ | The Dark Side Of Solar Power | Kristina Panos | [
"Featured",
"green hacks",
"Interest",
"Original Art",
"Slider"
] | [
"EOL",
"monocrystalline",
"photovoltaic",
"polycrystalline",
"Quartz",
"recycling",
"renewable energy",
"silicon",
"silver",
"solar panels"
] | Everybody loves solar power, right? It’s nice, clean, renewable energy that’s available pretty much everywhere the sun shines. If only the panels weren’t so expensive. Even better,
solar is now the cheapest form of electricity for companies to build
, according to the International Energy Agency. But solar isn’t all apples and sunshine — there’s a dark side you might not know about.
Manufacturing solar panels is a dirty process from start to finish
. Mining quartz for silicon causes the lung disease silicosis, and the production of solar cells uses a lot of energy, water, and toxic chemicals.
The other issue is that solar cells have a guanteed life expectancy of about 25 years, with
average efficiency losses of 0.5% per year
. If replacement begins after 25 years, time is running out for all the panels that were installed during the early 2000s boom. The International Renewable Energy Agency (IREA) projects that by 2050, we’ll be looking at 78 million metric tons of bulky e-waste. The IREA also believe that we’ll be generating six million metric tons of new solar e-waste every year by then, too. Unfortunately, there are hardly any measures in place to recycle solar panels, at least in the US.
How are solar panels made, anyway? And why is it so hard to recycle them? Let’s shed some light on the subject.
How It’s Made: Solar Panels
Monocrystalline and polycrystalline panels. Images via
AZoCleantech
and
HaHaSmart Solar
Solar panels come in three basic types — monocrystalline, polycrystalline, and thin-film. Each cell of a monocrystalline solar panel is made from a single silicon crystal. These are the single malt Scotch of solar panels, and are usually black.
Polycrystalline panels have a jumbled, multi-faceted look to them because they’re made from several silicon crystals. These panels are usually blue, and this is because of a coating that makes them perform better. Thin-film solar panels are the type you see in solar calculators and watches, and they offer the least efficiency. These are made from amorphous silicon, which is why they look so different from the other two.
Extracting silicon from quartz requires an insanely hot furnace and a long pole. Image via
How It’s Made
No matter the type, solar cells start with sand, usually high-purity quartz sandblasted at high temperatures. The quartz is first refined into metallurgical-grade silicon, then purified into polysilicon. This creates a highly toxic compound called silicon tetrachloride. This stuff is bad enough on its own, but
when it gets dumped and reaches local bodies of water, it releases hydrochloric acid
.
The resulting polysilicon is collected into rocks and melted together into ingots. Boron is added (known as
doping
) to give the silicon positive polarity. Then the ingots are sliced into paper-thin wafers that are coated with a substance that makes them absorb sunlight rather than reflect it.
The cells are treated with a phosphorus coating that negatively charges the surface, completing the p-n junction that makes it possible to convert the sun’s energy into electricity. The cells are baked in a furnace and then soldered together into panels. A layer of protective glass goes on the front, and a durable polymer goes on the back that keeps out dirt and debris.
So… Recycle Them?
If they are properly cleaned and maintained, solar panels can last for several decades. But as solar panels degrade, they become far less efficient, and eventually stop working altogether. The obvious solution might be to recycle all those solar panels, but it’s not that simple. People don’t go down to the big box store and buy solar panels directly, they buy them from companies who also install them. It’s left up to the companies to track the panels, take them back, and make sure they get recycled. The problem is that not everyone is aware that they can be recycled in the first place, and dumping them in landfills is not being policed much in the States.
Europe is really leading the way when it comes to e-waste recycling. The European Union have a law requiring that solar panel producers take back their panels at end of life and recycle them.
Britain has a refinery that uses microbes instead of cyanide to break down e-waste and extract the precious metals
. And France is home to Veolia, the world’s only commercial-scale photovoltaic recycling plant. In 2017 their partner PVCycle collected 2,400 tons of end-of-life panels throughout France. Veolia says they are able to achieve a 95% rate of re-usability for the collected metal and glass. Check out their process in the video below.
https://www.youtube.com/watch?v=PaUlSZ2biI8
In the US, there are no federal mandates for recycling solar panels, and only Washington state and New York have any kind of laws about them
.
As a result, only about 10% of American panels are recycled
. The other 90% get shipped to countries without mandates for reuse, or end up in landfills, leaching lead and other toxic chemicals into the Earth.
Right now in the US, recycling solar panels is difficult, and recovering the silver, copper, and silicon requires custom solutions. Scrapping the aluminum frames and silver from the metallization paste doesn’t net that much, and it costs $12-25 per panel plus transportation costs to recycle them. Dumping them in landfills only costs about $1 per panel.
It’s hard to compare the damage done by the solar panel manufacturing process to the damage caused by burning fossil fuels for energy. Neither one is good, so are we solving one problem while creating another? If we don’t figure out a global scheme for recycling panels, we’re certainly headed for a crisis. | 303 | 47 | [
{
"comment_id": "6299479",
"author": "david s",
"timestamp": "2020-12-02T15:20:33",
"content": "I still wish we’d go heavy on natural gas and invest in carbon capture tech. With scale, I think it makes the most sense for a balance of affordable energy production, environmental protection, and “not i... | 1,760,373,268.924618 | ||
https://hackaday.com/2020/12/02/a-straightforward-guide-to-unlocking-the-nintendo-game-and-watch/ | A Straightforward Guide To Unlocking The Nintendo Game And Watch | Jenny List | [
"Nintendo Hacks"
] | [
"game and watch",
"nintendo",
"stm32"
] | Nintendo’s reborn tiny handheld game has certainly attracted the attention of hardware hackers, and we’ve been treated to a succession of exploits as its secrets have been one by one unlocked. With relatively straightforward hardware it conceals potential far beyond a simple
Mario
game or two, and it’s now at the stage of having a path to dumping both its SPI Flash and internal Flash, unlocking its processor, and running arbitrary code.
The process of unlocking it is now atraightforward enough to warrant a HOWTO video
, to which [stacksmashing] has treated us. It’s early days and this is still touted as for developers rather than gamers, but it serves to show where work on this console is going.
The console’s STM32 architecture means that programming hardware is straightforward enough to find, though we’re cautioned against using the cheap AliExpress type we might use with a Blue Pill or similar. Instead the snap-off programmer that comes with an STM Nucleo board is a safer choice that many people are likely to have already.
The relative simplicity of the process as seen in the video below must conceal an immense amount of work from multiple people. It’s a succession of scripts to sequentially unlock and back up the various firmwares with STM payloads for each step. Finally the STM32 itself is unlocked, and the backed-up Nintendo firmware can be returned to the device or instead a custom firmware can be created. Aside from
the DOOM we’ve already seen
there are work-in-progress NES and Game Boy emulators, and fascinatingly also work on bare-metal games.
Given the lack of custom chips in this console it is easily possible that its hardware could be directly cloned and that Nintendo might have unintentionally created a new general purpose hacker’s handheld gaming platform. There are a few hardware works-in-progress such as increasing the SPI Flash size and finding the unconnected USB pins, so we look forward to more exciting news from this quarter. | 15 | 5 | [
{
"comment_id": "6299471",
"author": "Severe Tire Damage",
"timestamp": "2020-12-02T14:48:35",
"content": "I was curious that he cautioned against using the AliExpress ST_link gadgets, since I have been using them daily for many months. But he does give concrete reasons. One is that they don’t pr... | 1,760,373,268.315897 | ||
https://hackaday.com/2020/12/02/diaphragm-air-engine/ | Diaphragm Air Engine | Danie Conradie | [
"Misc Hacks"
] | [
"compressed air",
"design",
"engine",
"model aircraft",
"tom stanton"
] | One of the tricky parts of engineering in the physical world is making machines work with the available resources and manufacturing technologies. [Tom Stanton] has designed and made a couple of air-powered 3D printed engines but always struggled with the problem of air leaking past the 3D-printed pistons. Instead of trying to make an air-tight piston, he added a rubber membrane and a clever valve system to create a
diaphragm air engine
.
This GIF is worth 115 words
A round rubber diaphragm with a hole in the center creates a seal with the piston at the top of its stroke. A brass sleeve and pin protrude through the diaphragm, and the sleeve seals create a plug with an o-ring, while the pin pushes open a ball which acts as the inlet valve to pressurize an intermediate chamber. As the piston retracts, the ball closes the inlet valve, the outlet valve of the intermediate chamber is opened, forcing the diaphragm to push against the piston. The seal between the piston and diaphragm holds until the piston reaches its bottom position, where the pressurized air is vented past the piston and out through the gearbox. For full details see the video after the break.
It took a few iterations to get the engine to run. The volume of the intermediate chamber had to increase and [Tom] had to try a few different combinations of the sleeve and pin lengths to get the inlet timing right. Since he wanted to use the motor on a plane, he compared the thrust of the latest design with that of the
previous version
. The latest design improved efficiency by 366%. We look forward to seeing it fly!
Most of our regular readers have seen [Tom]’s
array
of
flying machines
, and he has also tested alternative power sources like
kinetic energy stored in a flywheel
. | 31 | 10 | [
{
"comment_id": "6299433",
"author": "drKonya",
"timestamp": "2020-12-02T09:59:29",
"content": "“This GIF is worth 115 words”Am i the only one who selected the corresponding part of the text and checked it in an online word counter app? =)",
"parent_id": null,
"depth": 1,
"replies": [
... | 1,760,373,268.998012 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.