Display technology has improved by leaps and bounds over the last few years, thanks in no small part to the smartphone revolution. High-resolution LCD panels are dirt cheap and easy to interface with. There’s absolutely no logical reason to try and show images on a 32×32 array of RGB LEDs. But that didn’t stop [Felix Spöttel] from doing it anyway.

The project, which he calls thirtytwopixels, was designed to work in conjunction with MPD (Music Player Daemon) to show the album art for whatever is currently playing. The ultra-low resolution display added a certain element of abstractness to the artwork, which [Felix] said made it an interesting conversation starter. Guests would try and guess what the album art was depicting given the sparse rendition shown on the matrix.

[Felix] gives an excellent explanation of how to get the server and client-side software up and running should you want to recreate his setup, but his Python scripts also have a function where you can push an arbitrary image to the display if you don’t want to connect everything up to the MPD backend.

On the hardware side, thirtytwopixels uses the Raspberry Pi Zero W, a Adafruit RGB Matrix Bonnet, and a 32×32 LED matrix that uses the HUB75 interface. Even a relatively small LED matrix like this can get pretty thirsty, so [Felix] is using a 5 volt power supply that can deliver 4 amps to keep the electronics happy.

If you wanted to keep the low resolution aesthetic but make the display larger, we’ve seen WS2812B LED strips and 3D printed frames used to make a custom jumbo matrix which could surely be adapted for this concept.

source https://hackaday.com/2020/10/11/lo-fi-art-on-a-32×32-matrix/

Display technology has improved by leaps and bounds over the last few years, thanks in no small part to the smartphone revolution. High-resolution LCD panels are dirt cheap and easy to interface with. There’s absolutely no logical reason to try and show images on a 32×32 array of RGB LEDs. But that didn’t stop [Felix Spöttel] from doing it anyway.

The project, which he calls thirtytwopixels, was designed to work in conjunction with MPD (Music Player Daemon) to show the album art for whatever is currently playing. The ultra-low resolution display added a certain element of abstractness to the artwork, which [Felix] said made it an interesting conversation starter. Guests would try and guess what the album art was depicting given the sparse rendition shown on the matrix.

[Felix] gives an excellent explanation of how to get the server and client-side software up and running should you want to recreate his setup, but his Python scripts also have a function where you can push an arbitrary image to the display if you don’t want to connect everything up to the MPD backend.

On the hardware side, thirtytwopixels uses the Raspberry Pi Zero W, a Adafruit RGB Matrix Bonnet, and a 32×32 LED matrix that uses the HUB75 interface. Even a relatively small LED matrix like this can get pretty thirsty, so [Felix] is using a 5 volt power supply that can deliver 4 amps to keep the electronics happy.

If you wanted to keep the low resolution aesthetic but make the display larger, we’ve seen WS2812B LED strips and 3D printed frames used to make a custom jumbo matrix which could surely be adapted for this concept.

source https://hackaday.com/2020/10/11/lo-fi-art-on-a-32×32-matrix/

There is a certain magic and uniqueness to hardware, particularly when it comes to audio. Tube amplifiers are well-known and well-loved by audio enthusiasts and musicians alike. However, that uniqueness also comes with the price of the fact that gear takes up space and cannot be configured outside the bounds of what it was designed to do. [keyth72] has decided to take it upon themselves to recreate the smooth sound of the Fenders Blues Jr. small tube guitar amp. But rather than using hardware or standard audio software, the magic of AI was thrown at it.

In some ways, recreating a transformation is exactly what AI is designed for. There’s a clear and recordable input with a similar output. In this case, [keyth72] recorded several guitar sessions with the guitar audio sent through the device they wanted to recreate. Using WaveNet, they created a model that applies the transform to input audio in real-time. The Gain and EQ knobs were handled outside the model itself to keep things simple. Instructions on how to train your own model are included on the GitHub page.

While the model is simply approximating the real hardware, it still sounds quite impressive, and perhaps the next time you need a particular sound of your home-built amp or guitar pedal, you might reach for your computer instead.

source https://hackaday.com/2020/10/11/tube-amp-is-modeled-with-the-power-of-ai/

Building a retro computer, or even restoring one, is a great way to understand a lot of the fundamentals of computing. That can take a long time and a lot of energy, though. Luckily, there is a Twitter bot out there that can let you experience an old 8-bit Atari without even needing to spin up an emulator. Just tweet your program to the bot, and it outputs the result.

The bot was built by [Kay Savets] and accepts programs in five programming languages: Atari BASIC, Turbo-Basic XL, Atari Logo, Atari PILOT, and Atari Assembler/Editor, which was a low-level assembly-type language available on these machines. The bot itself runs on a Raspberry Pi with the Atari 800 emulator, rather than original hardware, presumably because it’s much simpler to get a working network connection on a Pi than on a computer from the 80s. The Pi runs a python script that polls Twitter every two minutes and then hands the code off to the emulator.

[Kay]’s work isn’t limited to just Ataris, though. There’s also an Apple II BASIC bot for all the Apple fans out there that responds to programs written in AppleSoft BASIC. While building your own retro system or emulating one on other hardware is a great exercise, it’s also great that there are tools like these that allow manipulation of retro computers without having to do any of the dirty work ourselves.

source https://hackaday.com/2020/10/11/access-an-8-bit-atari-through-twitter/

How many people still have a PS/2 keyboard kicking around in 2020? Admittedly asking such a question of the Hackaday audience is probably cheating (there’s a decent chance one of you will type a comment on one just to prove a point), but even the most pedantic reader has to admit that it’s a long dead standard. So we’re hardly surprised to hear that [Turbaned Engineer] didn’t have one handy when he tried to boot a motherboard so old that he couldn’t access the BIOS with a USB keyboard.

But rather than waiting for an adapter to show up in the mail, he decided to rig up an Arduino Nano to mimic a PS/2 keyboard just long enough for him to navigate the system configuration. Since that basically meant he only needed the arrow keys and Enter, he was able to rig up a handful of momentary buttons to serve as input. We wouldn’t recommend typing out your memoirs with such a spartan board, but it’s certainly good enough to juggle around the order of boot devices.

The fun didn’t stop there, though. [Turbaned Engineer] also had to clean some corrosion and fix a blown resistor on a bank of RAM to drag this old soldier over the finish line. He didn’t have a case handy, so he made a free-form one using the polycarbonate packaging that ICs ship in. The final machine isn’t exactly a sleeper, but it’s good enough to play Super Mario Bros. 3 on the TV.

At the end of the day, the minimal input device [Turbaned Engineer] put together isn’t so far removed from other homebrew keyboards we’ve seen recently. It seems that QMK even has some basic support for the PS/2 interface. Not that it would come up very often, but a “retro” mode might be an interesting addition to your next custom keyboard build.

source https://hackaday.com/2020/10/11/arduino-gets-old-pc-booted-and-back-into-action/

Master of 3D printed robots, [James Bruton], plans to do some autonomous rover projects in the future, but first, he needed a modular rover platform. Everything is cooler with tank tracks, so he built a rover with flexible interlocking track sections.

The track sections are printed with flexible Ninjaflex filament. Each section has a tab designed to slot through two neighboring pieces. The ends of the tabs stick through on the inside of the track fit into slots on the drive wheel like gear teeth. This prevents the track from slipping under load. The Ninjaflex is almost too flexible, allowing the tracks to stretch and almost climb off the wheels, so [James] plans to experiment with some other materials in the future. The chassis consists of two 2020 T-slot extrusions, which allows convenient mounting of the wheel bogies and other components.

For initial driving tests [James] fitted two completely overpowered 1500 W brushless motors that he had on hand, which he plans to replace with smaller geared DC motors at a later stage.

A standard RC system is used for control, but it does not offer a simple way to control a skid steer vehicle. To solve this, [James] added an Arduino between the RC receiver and the motor ESC. It converts the PWM throttle and turn signal from the transmitter, and combines is into differential PWM outputs for the two ESCs.

We look forward to seeing what [James] does with the rover. It seems like the perfect platform for the new Nvidia Jetson Nano 2GB. A while back [rctestflight] built also built an interesting tracker 3D printed rover, which can run autonomously with Ardurover, and sometimes lives out at his flying field.

source https://hackaday.com/2020/10/11/modular-rover-platform-rolls-on-3d-printed-flexible-tank-tracks/

Master of 3D printed robots, [James Bruton], plans to do some autonomous rover projects in the future, but first, he needed a modular rover platform. Everything is cooler with tank tracks, so he built a rover with flexible interlocking track sections.

The track sections are printed with flexible Ninjaflex filament. Each section has a tab designed to slot through two neighboring pieces. The ends of the tabs stick through on the inside of the track fit into slots on the drive wheel like gear teeth. This prevents the track from slipping under load. The Ninjaflex is almost too flexible, allowing the tracks to stretch and almost climb off the wheels, so [James] plans to experiment with some other materials in the future. The chassis consists of two 2020 T-slot extrusions, which allows convenient mounting of the wheel bogies and other components.

For initial driving tests [James] fitted two completely overpowered 1500 W brushless motors that he had on hand, which he plans to replace with smaller geared DC motors at a later stage.

A standard RC system is used for control, but it does not offer a simple way to control a skid steer vehicle. To solve this, [James] added an Arduino between the RC receiver and the motor ESC. It converts the PWM throttle and turn signal from the transmitter, and combines is into differential PWM outputs for the two ESCs.

We look forward to seeing what [James] does with the rover. It seems like the perfect platform for the new Nvidia Jetson Nano 2GB. A while back [rctestflight] built also built an interesting tracker 3D printed rover, which can run autonomously with Ardurover, and sometimes lives out at his flying field.

source https://hackaday.com/2020/10/11/modular-rover-platform-rolls-on-3d-printed-flexible-tank-tracks/

Master of 3D printed robots, [James Bruton], plans to do some autonomous rover projects in the future, but first, he needed a modular rover platform. Everything is cooler with tank tracks, so he built a rover with flexible interlocking track sections.

The track sections are printed with flexible Ninjaflex filament. Each section has a tab designed to slot through two neighboring pieces. The ends of the tabs stick through on the inside of the track fit into slots on the drive wheel like gear teeth. This prevents the track from slipping under load. The Ninjaflex is almost too flexible, allowing the tracks to stretch and almost climb off the wheels, so [James] plans to experiment with some other materials in the future. The chassis consists of two 2020 T-slot extrusions, which allows convenient mounting of the wheel bogies and other components.

For initial driving tests [James] fitted two completely overpowered 1500 W brushless motors that he had on hand, which he plans to replace with smaller geared DC motors at a later stage.

A standard RC system is used for control, but it does not offer a simple way to control a skid steer vehicle. To solve this, [James] added an Arduino between the RC receiver and the motor ESC. It converts the PWM throttle and turn signal from the transmitter, and combines is into differential PWM outputs for the two ESCs.

We look forward to seeing what [James] does with the rover. It seems like the perfect platform for the new Nvidia Jetson Nano 2GB. A while back [rctestflight] built also built an interesting tracker 3D printed rover, which can run autonomously with Ardurover, and sometimes lives out at his flying field.

source https://hackaday.com/2020/10/11/modular-rover-platform-rolls-on-3d-printed-flexible-tank-tracks/

What do you do with an old cable modem in a closet? If you are [stdw] you reverse engineer it and turn it into a software-defined radio. The modem in question was a Motorola MB7220. After looking at a similar project using a different modem, it seemed like it should be doable.

Cracking open the case revealed two likely UART ports, one of which was active. The output from that UART provided a lot of info. The chip was a Broadcom BCM3383 which is a MIPS processor. It had eCos as an operating system. However, the bootloader eventually disables the UART, so there wasn’t much more investigation possible via the serial terminal.

The next step was to dump the flash memory. That required a little solder surgery to prevent the board from starting while the flash chip had power. It appeared that some key credentials and configuration data were present, but they were really backups. After doing a factory reset to remove the backups, the right data was apparent.

After some lengthy exploration, the diagnostic that builds a spectrum display gave up its data. At first, the data was just a small sample of what was really required, but it did show a local FM station as a spectrum. Eventually, the data loss rate was down to about 12% when streaming which is not great, but good enough. You can hear an audio clip of the reception. Not exactly crystal-clear quality, but not bad.

Of course, no one will use this for an FM radio. But it is a fascinating view into how far you can hack into a device like this if you have some skills and patience. There must be something about quarantine that is making people hack old gear, as we just recently saw a similar Netgear hack. Even cheap games aren’t safe.

source https://hackaday.com/2020/10/10/the-cable-modem-to-sdr-transformation/

At one time or another, most of us have seen a gadget for sale and thought we could build something similar for cheaper. Of course, we’re almost always wrong. Not about being able to build it, mind you. But when you add up the cost of the materials, the tool or two you almost inevitably end up buying, and the time spent chasing perfection, you’re lucky if you haven’t doubled the original price.

We’re not sure how much money, if any, [Taylor Hay] ended up saving by building his own portable power bank. But we do know it’s a gorgeous piece of hardware that’s certainly built far better than the average piece of consumer tech. The CNC-cut aluminum side panels look like something pulled out of a tank, and while we know some might balk at the 3D printed internal frame, we’re confident you could use this thing as an impromptu step stool without a problem.

Inside there’s 150 watt 240 VAC inverter, complete with a temperature-controlled fan to keep it cool under load. There are also four USB ports providing 2.1 A each, a standard 12 VDC accessory port, and a LED display that shows battery voltage and current being drawn. Rather than come up with his own battery pack, [Taylor] used a 3D printed interface that accepts an 18 V Milwaukee cordless tool battery. Naturally, the design could be adapted to take another brand’s cells if you were so inclined.

Around these parts, we know that a good project doesn’t have to be cheaper or even more practical than what’s already on the market. There’s an inherent value in building something exactly the way you want it that you simply can’t put a monetary price on.

source https://hackaday.com/2020/10/10/heavy-metal-power-bank-uses-tool-batteries/

We are no stranger to peculiar and wonderful musical instruments here at Hackaday. [James Bruton] has long been fascinated with barcode scanners as an input source for music and now has a procedural barcode-powered synth to add to his growing collection of handmade instruments. We’ve previously covered his barcode guitar, which converts a string of numbers from the PS/2 output to pitches. This meant having a large number of barcodes printed as each pitch required a separate barcode. As you can imagine, this makes for a rather unwieldy and large instrument.

Rather than looking at the textual output of the reader, [James] cracked it open and put it to the oscilloscope. Once inside, he found a good source that outputs a square wave corresponding to the black and white lines that the barcode sees. Since the barcodes [James] is using don’t have the proper start and stop codes, the barcode reader continuously scans.  Normally it would stop the laser to send the text over the USB or PS/2 connection. A simple 5v to 3.3v level shifter feeds that square wave into a Teensy board, which outputs the audio.

A video showcasing a similar technique inspired [James] with this project. The creators of that video have a huge wall of different patterns of black and white lines. [James’s] next stroke of brilliance was to have a small HDMI display to generate the barcodes on the fly. A Raspberry Pi 4 reads in various buttons via GPIO and displays the resulting barcode on the screen. A quick 3d printed shell rounds out the build nicely, keeping things small and compact. All the code and CAD files are up on GitHub.

Thanks [James Bruton] for the awesome project!

source https://hackaday.com/2020/10/10/procedural-barcode-synth-is-as-simple-as-black-and-white/

Ordinarily, when we need gears, we pop open a McMaster catalog or head to the KHK website. Some of the more adventurous may even laser cut or 3D print them. But what about machining them yourself?

[Uri Tuchman] set out to do just that. Of course, cutting your own gears isn’t any fun if you didn’t also build the machine that does the cutting, right? And let’s be honest, what’s the point of making the machine in the first place if it doesn’t double as a work of art?

[Uri’s] machine, made from brass and wood, is simple in its premise. It is placed adjacent to a gear cutter, a spinning tool that cuts the correct involute profile that constitutes a gear tooth. The gear-to-be is mounted in the center, atop a hole-filled plate called the dividing plate. The dividing plate can be rotated about its center and translated along linear stages, and a pin drops into each hole on the plate as it moves to index the location of each gear tooth and lock the machine for cutting.

The most impressive part [Uri’s] machine is that it was made almost entirely with hand tools. The most advanced piece of equipment he used in the build is a lathe, and even for those operations he hand-held the cutting tool. The result is an elegant mechanism as beautiful as it is functional — one that would look at home on a workbench in the late 19th century.

[Thanks BaldPower]

source https://hackaday.com/2020/10/10/homemade-gear-cutting-indexer-blends-art-with-engineering/

WiFi is an ubiquitous feature of the modern landscape, but due to power restrictions on most hardware alongside the high-frequency signal it’s typically fairly limited in range. This of course leads to frustration where a WiFi signal can be seen, but the connection is unreliable or slow. While most would reach for a range extender or other hardware bridge, [tak786] was able to roll out a better solution for his workplace by using a high-gain antenna and a single-board computer which gets him an amazing kilometer-wide WiFi network.

The build uses a 10 dBi antenna from TP-Link that’s rated for outdoor use and a single-board computer which acts as a sort of router. The antenna is placed at the top of a building which certainly helps with the extreme range as well. This setup doesn’t actually broadcast an open Internet connection, though. [tak786]’s employer needed a teleconferencing solution for their building, and he also created a fully open-source video conferencing solution called trango that can run on any LAN and doesn’t require an Internet connection. The WiFi setup in this build is effectively just a bonus to make the conferencing system more effective.

[tak786] is planning on releasing a whitepaper about this build shortly, but for now you can access the source code for the video conferencing system at his GitHub page. And, before anyone jumps to conclusions, apparently this is well within FCC rules as well. Some of the comments in the linked Reddit post suggest that with an amateur radio license this system could be pushed much further, too. If you need more range than a kilometer, though, it’s not too much more difficult to do once you have all the right hardware.

source https://hackaday.com/2020/10/10/long-range-wifi-broadcasts-open-source-video-conferencing/

The rise of smartphone and smartwatch fitness tracking has been an absolute boon for anyone interested in tracking their runs. However, it all falls short when you need a custom feature and start getting into serious long distance running, as most smartphone batteries simply won’t last. While there are devices out there for the ultra-running enthusiast, [Ivor Hewitt] decided he wasn’t willing to pay a monthly subscription for the pricy trackers or deal with the hassle of the generic cheap versions, and decided to roll his own.

The key pieces of this project are the A9G GPS module and the RDA8955 GRS/GPRS module. They’re both incredibly small and power efficient, perfect for a project that needs to be worn on your person with a long battery life. As an added bonus, the RDA8955 also includes a SoC that’s user-programmable. After battling the lackluster documentation and tooling, [Ivor] managed to get some software running on his new system. A power bug on the A9G GPS module was potentially show stopping, but thanks to some help by folks in the community, it was diagnosed and solved.

Further additions included adding a proper charging circuit (TP4056) and a beefy 2600 mAh battery scavenged from a Sony smartphone, giving the compact system around 38 hours of active battery life. An OLED screen was added to show upcoming aid stations and overall system status, driven by a custom display library. A snazzy translucent case makes the whole device slim and easy to carry. Now at the end of a long race or training session, [Ivor] has a wealth of tracked points that has already been uploaded to his own tracking website and a fully charged phone.

Next time you’re looking for a small compact GPS tracker or cellular logger take a look at this project’s code on GitHub or the A9G and RDA8955 modules.

Thanks [Ivor] for sending this one in!

source https://hackaday.com/2020/10/09/tracking-your-run-over-the-long-haul/

If you ask power companies and cell phone carriers how much electromagnetic radiation affects the human body, they’ll tell you it doesn’t at any normal levels. If you ask [Calvin Carter] and some other researchers at the University of Iowa, they will tell you that it might treat diabetes. In a recent paper in Cell Metabolism, they’ve reported that exposing patients to static magnetic and electric fields led to improved insulin sensitivity in diabetic mice.

Some of the medical jargon in a paper like this one can be hard to follow, but it seems they feed mice on a bad diet — like that which many of us may eat — and exposed them to magnetic and electrical fields much higher than that of the Earth’s normal fields. After 30 days there was a 33% improvement in fasting blood glucose levels and even more for some mice with a specific cause of diabetes.

The magnetic field was 3 mT and the electric field was 7 kV/m. That sounds like a lot, but at sea level we normally experience about 120 V/m, so it’s hardly the equivalent of grabbing a live wire.

Interestingly, the same effect occurred when the mice were exposed for only seven hours a day. You can infer then that one day, diabetics might just sleep under an electromagnetic field and have improved glucose metabolism.

There’s some medical speak about why they think this works, but it was pretty dense on biology terms. The key phrase seems to be “modulating the systemic GSH/GSSG redox environment.” GSH/GSSG is the glutathione-to-glutathione disulfide redox couples, if that tells you anything.

This would be amazing news for people with diabetes, especially if they don’t decide it also causes blindness, cancer, and restless leg syndrome. No more fake pancreas! We don’t know, though, if the results would apply to type 1 diabetes as it sounds like the mice all had type 2.

source https://hackaday.com/2020/10/09/electronic-treatment-for-diabetes/

A while back, [Kutluhan Aktar] was trying to hack their chickens, quails, and ducks for higher egg production and faster hatching times by using a bit of classical conditioning. That is, feeding them at the same time every day while simultaneously exposing them to sound and light. Once [Kutluhan] slipped enough times, they hatched a plan to build an automatic feeder.

This fun rooster-shaped bird feeder runs on an Arduino Nano and gets its time, date, and temperature info from a DS3231 RTC. All [Kutluhan] has to do is set the daily feeding time. When it comes, a pair of servos and a pan-tilt kit work together to invert a Pringles can filled with food pellets. A piezo buzzer and a green LED provide the sound and light to help with conditioning. Scratch your way past the break to see it in action.

If [Kutluhan] gets tired of watching the birds eat at the same time every day, perhaps a trash-for-treats training program could be next on the list.

Via r/duino

source https://hackaday.com/2020/10/09/classical-poultry-conditioning-is-a-bird-brained-scheme/

With all the cool and useful parts you can whip up (relatively) quickly on a 3D printer, it’s a shame you can’t just print a PCB. Sure, ordering a PCB is quick, easy, and cheap, but being able to print one-offs would peg the needle on the instant gratification meter.

[Peter Liwyj] may just have come up with a method to do exactly that. His Instructables post goes into great detail about his method, which uses an Elegoo Mars resin printer and a couple of neat tricks. First, a properly cleaned board is placed copper-side down onto a blob of SLA resin sitting on the print bed. He tricks the printer into thinking the platform is all the way down for the first layer by interrupting the photosensor used to detect home. He lets the printer go through one layer of an STL file that contains his design, which polymerizes a thin layer of plastic onto the copper. The excess resin is wiped gently away and the board goes straight into a ferric chloride etching bath. The video below shows the whole process.

As simple as it sounds, it looks like it works really well. And [Peter] didn’t just stumble onto this method; he approached it systematically and found what works best. His tips incude using electrical tape as a spacer to lift the copper off the print surface slightly, cleaning the board with Scotchbrite rather than sandpaper, and not curing the resin after printing. His toolchain is a bit uncoventional — he used SketchUp to create the traces and exported the STL. But there are ways to convert Gerbers to STLs, so your favorite EDA package can probably fit in to the process too.

Don’t have a resin printer? Don’t worry — FDM printers can work too.

Thanks to [abetusk] for the tip.

source https://hackaday.com/2020/10/09/put-that-new-resin-printer-to-work-making-pcbs/

Hackaday editors Elliot Williams and Mike Szczys riff on the hardware hacks that took the Internet by storm this week. Machining siege weapons out of aluminum? If they can throw a tennis ball at 180 mph, yes please! Welding aficionados will love to see the Hero Engine come together. We dive into the high-efficiency game of hypermiling, and spin up the polarizing topic of the Sun Cycle. The episode wouldn’t be complete without hearing what the game of Go sounds like as a loop sequencer, and how a variable speed cassette player can be abused for the benefit of MIDI lovers the world over.

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 Play
• iTunes
• Soundcloud
• Spotify
• Stitcher
• RSS

Episode 087 Show Notes:

New This Week:

• Hackaday Passes 1,000,000 Comments
  • The Pioneering Lifestyle In Low Earth Orbit
• Video: Exploring The Abandoned Birthplace Of The 6502 And Commodore 64

Interesting Hacks of the Week:

• Video: Exploring The Abandoned Birthplace Of The 6502 And Commodore 64
• Reel In The Years With A Cassette Player Synth
  • Zachteman Mini Mellotron made out of one Walkman.
  • Mellotron – Wikipedia
  • Tape-Head Robot Listens to the Floor
• The Amazing Technicolor Parts Organizer
  • Light the Way to Every Component
• Flywheel Trebuchet Spins Right Round
  • Trebucheting Tennis Balls At 124 MPH
  • Tracker Video Analysis and Modeling Tool for Physics Education
• Cleaning Up The Yard With AI — Avian Intelligence
  • BirdBox_gym_topside – YouTube
• Making Music With A Go Board Step Sequencer
  • Orbs Light to Billie Jean on this Huge Sequencer
  • Augmented Reality Sandbox Using A Kinect
• Making A Modern Version Of A Steam Engine From Antiquity
  • Hero’s Engine – YouTube

Quick Hacks:

• Elliot’s Picks:
  • Weigh Your Car With Paper
  • Clock Is Not Readable By Humans
  • Receipt Printers End It All In Moving Art Piece
• Mike’s Picks:
  • Custom Tool Helps Hakko Set Threaded Inserts
  • Teaching A Pocket Logic Analyzer (Many) New Tricks
  • Minimal TinyAVR 0 Programming

Can’t-Miss Articles:

• How To Get Into Cars: Hypermiling Mods
• Welcome To Solar Cycle 25; Our Sun Enters A New 11-Year Period

source https://hackaday.com/2020/10/09/hackaday-podcast-088-flywheel-trebuchet-thieving-magpies-hero-engines-and-hypermiling/

Depending on the circles you run in, it can seem like the mechanical keyboard community is all about reduced layouts, and keebs without ten-keys are about as big as it gets. But trust us, there’s plenty of love out there for the bigger ‘boards like [Ben]’s tasty fat-bottomed keyboard. Man oh man, what a delicious slab of throwback to the days when keyboards doubled as melee weapons.

More specifically, this is a 199-key modified Sun Type 5 layout. It runs on two Teensy 2.0s — one for the keyboard matrix, and one for everything else. [Ben] made the metal enclosure entirely by hand without a CNC or laser cutter. While I don’t personally care for linear switches, I have mad respect for these, which are vintage Cherry Blacks pulled from various 1980s AT/XT boards. That 10-key island on the left is dedicated to elementary macros like undo/redo, cut/copy/paste, and open/close/save.

We absolutely love the gigantic rotary encoders, which give it a bit of a boombox look. There’s even reuse involved here, because the encoder knobs are made from jam jar lids that are stuffed with homemade Sugru. [Ben] can use them to play PONG on the LCD and other games not yet implemented on the everything-else Teensy.

Here’s another Sun-inspired keeb, but this one has a reverse 10-key layout that matches the DTMF phone dial.

source https://hackaday.com/2020/10/09/fat-bottomed-keebs-you-make-the-clackin-world-go-round/

GitHub has enabled free code analysis on public repositories. This is the fruit of the purchase of Semmle, almost exactly one year ago. Anyone with write permissions to a repository can go into the settings, and enable scanning. Beyond the obvious use case of finding vulnerabilities, an exciting option is to automatically analyse pull requests and flag potential security problems automatically. I definitely look forward to seeing this tool in action.

The Code Scanning option is under the Security tab, and the process to enable it only takes a few seconds. I flipped the switch on one of my repos, and it found a handful of issues that are worth looking in to. An important note, anyone can run the tool on a forked repo and see the results. If CodeQL finds an issue, it’s essentially publicly available for anyone who cares to look for it.

Simpler Code Scanning

On the extreme other hand, [Will Butler] wrote a guide to searching for exploits using grep. A simple example, if raw shows up in code, it often signals an unsafe operation. The terms fixme or todo, often in comments, can signal a known security problem that has yet to be fixed. Another example is unsafe, which is an actual keyword in some languages, like Rust. If a Rust project is going to have vulnerabilities, they will likely be in an unsafe block. There are some other language-dependent pointers, and other good tips, so check it out.

Stalking on Google

Real-world attacks, at least targeted attacks, involve lots of intelligence gathering on the target. Lots of data is available in the open on platforms like Facebook and Google, but sometimes it’s a pain to actually pull that data together. [mxrch] has published a tool specifically targeting Google accounts. Supply an email address, and GHunt attempts to scrape any public information available about that account.

What information might be available? First off, it looks for activity from that account on other Google services. YouTube, Google Maps, and Google Photos can be great sources of information. What’s not obvious about that is the extra information available from those sources. Images shared on Google Maps seems to have their metadata cleaned, but pictures left public on Google Photos don’t. Location data, camera hardware, and more interesting information is right there, so long as you know where to look. It would be interesting to stand up a GHunt instance and run it against your own Google account, just to see what information is out there.

New Malware, Old Malware

Emotet has been around since 2014, and has proven to be the gift that keeps on giving. Ars has a brief history of the malware, and it’s an impressive run. It’s apparent that whoever is behind Emotet has continued developing the malware. The most puzzling development is the five months earlier this year when Emotet went silent, only to return via an aggressive spam presence. Perhaps even cyber-criminals took time off for Coronavirus.

An even older malware campaign with clearer provenance has popped up again. FinSpy was created by FinFisher as a commercial spyware tool. Amnesty International has been reporting on spyware campaigns launched against political activists for quite some time, and often their reports include interesting technical tidbits. This one is no exception, as they break the news that FinSpy now targets MacOS and Linux machines. The observed Linux binary is simply named PDF, leading me to suspect the primary infection mechanism is phishing.

Attacking the Seams in the Cloud

Our friends at Google’s Project Zero set their sights on HashiCorp’s Vault project (It’s Open Source). Vault looks like a really useful project, as it handles data encryption for shared data sets. Want to build a complex web service where data is properly encrypted at rest, but still accessible to multiple users? Vault might be worth looking at.

Not all is perfect in paradise. One of the common places to find security problems is the interface between the elements of a service. In this case, [Felix] found an issue where Vault interfaces with the AWS authentication service. A user can request access to an object, and Vault will turn around and forward that request to Amazon’s user authentication mechanism. The function that handles that response accepts either XML or JSON encoding. As it turns out, that function will also accepts messages that include *both* types of encoding. The trick was to find a way to get Amazon’s service to reflect an authentication request that included JSON supplied by the user. The intended response is in XML: “Yes, this person exists”. Also included in that message is a JSON spoofed response: “This person is a superuser”.

There’s another attack vector detailed in the article, so go get the full scoop if it strikes your fancy. The point is made that as cloud-based applications become more common, this sort of vulnerability will be seen more often, as well. It’s a different paradigm, looking at cloud security as compared to conventional computer security.

Jailbreaking Macs

The jailbreaking community have been punching holes in Apple mobile hardware for years. What about desktop hardware? Do the flaws used in iOS jailbreaks also work on Macs? A few of them, yes. A researcher at IronPeak Services put together a summary of the current state of hardware attacks against MacOS machines. The good news is that this family of attacks require physical access, and because the vulnerable component has immutable firmware, the attack isn’t persistent. The bad news is that the immutable firmware cannot be patched, and all that is needed for compromise is a USB device.

Today’s Macs containing a co-processor, the T2. This chip is essentially the ARM A10 from Apple’s mobile devices, and handles quite a few system functions, including trusted computing via the Secure Enclave Processor (SEP) embedded inside. While the T2 firmware can be updated, the SEP firmware is read only, and can’t be touched. The shared hardware also means shared bugs, and a couple of those bugs exist in that immutable SEP firmware. Namely, Checkm8/Checkra1n. A USB device can trigger the jailbreak, and enable a debug mode. The end result is full root control over the T2 co-processor, and quite a bit of control over the entire system.

The need for a physical USB device means that this isn’t going to be used in widespread malicious attacks, but may prove useful for owners of the machines. The author claims that more is coming in the next few weeks. We’ll follow the story and let you know about it.

source https://hackaday.com/2020/10/09/this-week-in-security-code-scanning-information-gathering-and-seams-in-the-cloud/

Are you tired of cats and other wildlife relieving themselves in your outdoor plant pots? As if accidental neglect won’t kill them fast enough. [TecnoProfesor] has a solution, and it doesn’t even involve a microcontroller. It detects the presence of approaching animals and then blasts them with annoying sounds and a couple of bright green LEDs to drive them away.

Thanks to a couple of modules, the circuit is really pretty simple. There’s a PIR to detect the animals, a buzzer, and a 555-based pulse generator to play tones through the buzzer. This circuit can run 24/7 on a pair of 6V solar panels that charge up a battery. We particularly like the desk trash can enclosure, though we have to wonder how waterproof this system is. Check out the brief demo after the break.

For all of you satisfied with the 555 implementation here, your reward is this giant functioning 555. If you’re a 555 naysayer, how would you have done it better?

source https://hackaday.com/2020/10/09/tiny-trash-can-repels-trash-pandas-medium-sized-cats/

Simple drafting programs just let you draw like you’d use a pencil. But modern programs use parametric models to provide several benefits. One is that you can use parameters to change parts of your design and other parts will alter to take account of your changes. The other advantage is you can use one model for many similar but different designs. [Brodie Fairhall] has a nice video about how to use parameters in FreeCAD.

The nice thing about parameters is they don’t have to be just constants. You can put in formulae as well. For example, you could define one line as being twice as big as another line. You provide various constraints and parameters and FreeCAD works out the shape for you, keeping all the constraints and formulae satisfied.

[Brodie] shows how to use spreadsheets to manage complex parameters in big projects, which is pretty handy. There’s an upcoming feature that will allow you to group parameters into sets. As an example, you can see a model of a NEMA stepper motor that can change from a NEMA 17 to another size by just selecting different parameters from a configuration table.

OpenSCAD, of course, does nothing but parametric modeling in a very direct way. You code the constraints you want explicitly. We’ve also been enjoying Solvespace lately.

source https://hackaday.com/2020/10/09/freecad-parametrics-made-simple/

Teaching kids about robotics gives them valuable skills for their futures, and is generally pretty darn fun for all involved, too. However, teaching children often involves taking a bit of a different tack to educating college students, and more of a hand-holding approach is often needed. This robot project is an attempt to do just that, using some classic time-honored techniques and a unique method of propulsion.

The Magnetic Motion Robot, or MMR, is very much a DIY project. Built out of hand-cut plywood and assembled by lacing together individual modules, it’s a low-cost entry into the world of educational robotics. Rather than wheels or motors, it instead uses electromagnets mounted on servo arms to get around. Switching the magnets on and off, and moving the servos in time, allows the robot to pull itself along a ferromagnetic surface.

The robot is outfitted with buzzers and LEDs, and using these features creates further programming challenges for students. Naturally, there’s also a line-following program, which is a great way to begin educating kids about autonomous robot operations. It’s all run from an Arduino Nano, programmed with Makeblock’s special building-block programming software.

While its DIY nature makes assembly a little more involved than the average off-the-shelf kit, it does present its own learning opportunities such as soldering and the integration of hardware. Educational robots will continue to be popular and fun long into the future; we’re a particular fan of sumobots ourselves. Video after the break.

source https://hackaday.com/2020/10/08/educational-robot-teaches-with-magnets-and-servos/

Getting a product to market isn’t all about making sure that the product does what it’s supposed to. Granted, most of us will spend most of our time focusing on the functionality of our projects and less on the form, fit, or finish of the final product, especially for one-off builds that won’t get replicated. For those builds that do eventually leave the prototyping phase, though, a lot more effort goes into the final design and “feel” of the product than we might otherwise think. For example, this current sensor improves its feel by making use of cast concrete in its case.

The current sensor in this build is not too much out of the ordinary. [kevarek] built the sensor around the MCA1101-50-3 chip and added some extra features to improve its electrostatic discharge resistance and also to improve its electromagnetic compatibility over and above the recommended datasheet specifications. The custom case is where this one small detail popped out at us that we haven’t really seen much of before, though. [kevarek] mixed up a small batch of concrete to pour into the case simply because it feels better to have a weightier final product.

While he doesn’t mention building this current sensor to sell to a wider audience, this is exactly something that a final marketable product might have within itself to improve the way the device feels. Heavier things are associated, perhaps subconsciously, with higher quality, and since PCBs and plastic casings don’t weigh much on their own many manufacturers will add dummy weights to improve the relationship between weight and quality. Even though this modification is entirely separate from the function of the product, it’s not uncommon for small changes in design to have a measurable impact on performance, even when the original product remains unmodified.

Thanks to [Saabman] for the tip!

source https://hackaday.com/2020/10/08/current-sensor-makes-intriguing-use-of-concrete/

These days, when doing any sort of optical tracking, our mind immediately leaps towards sophisticated solutions. Raspberry Pis, high end cameras, and machine learning toolchains all come to mind. Of course, if your goals are simpler, you needn’t complicate the issue. PHIL is a light tracking robot who is perfectly happy to do it the old-school way.

PHIL consists of an Arduino Uno running a twin-servo motion platform, providing the sensor head with pan and tilt functionality. The sensor head itself consists of a 3D-printed cruciform-section shroud that mounts four light-dependent resistors in individual sections. The shroud helps block light to the off-angle sensors, giving a stronger difference between those exposed to the light directly and those on the dark side. This makes for a stronger difference signal, so when the Arduino reads the sensors, it’s much clearer which way PHIL should point the sensor head to follow the light.

The builder, [Sean O’Donovan], notes that PHIL was built with no practical purpose in mind, and is simply a cool project. We certainly agree, and it’s important to note that skills picked up on a project like this will invariably come in handy down the track. Such techniques can be highly useful for tracking the sun, for example. Video after the break.

source https://hackaday.com/2020/10/08/light-tracking-robot-relies-on-ldrs/