TV Turned Automatic Etch A Sketch With Raspberry Pi

Considering one of the biggest draws of the original Etch a Sketch was how simple it was, it’s always interesting to see the incredible lengths folks will go to recreate that low-tech experience with modern hardware. A perfect example is this giant wall mounted rendition of the iconic art toy created by [Ben Bernstein]. With a Raspberry Pi and some custom electronics onboard, it can even do its own drawing while you sit back and watch.

At a high level, what we’re seeing here is a standard Samsung LCD TV with a 3D printed Etch a Sketch shell mounted on top of it. That alone would be a pretty neat project, and had [Ben] just thrown some videos of designs getting sketched out onto the display, he could have achieved a similar end result with a lot less work. But where’s the fun in that?

It took hundreds of hours to print the shell.

To make his jumbo Etch a Sketch functional, [Ben] spent more than a year developing the hardware and software necessary to read the user input from the two large 3D printed knobs mounted under the TV. The knobs are connected to stepper motors with custom PCBs mounted to their backs that hold a A4988 driver chip as well as a AS5600 absolute magnetic rotary encoder. This solution allows the Raspberry Pi to not only read the rotation of the knobs when a person is using the Etch a Sketch interactively, but spin them realistically when the software takes over and starts doing an autonomous drawing.

Several Python scripts pull all the various pieces of hardware together and produce the final user interface. The software [Ben] wrote can take an image and generate paths that the Etch a Sketch can use to realistically draw it. The points that the line is to pass through, as well as variables that control knob rotation and pointer speed, are saved into a JSON file so they can easily be loaded later. Towards the end of the Imgur gallery [Ben] has created for this project, you can see the software working its way through a few example sketches.

We’ve seen several projects that motorize an Etch a Sketch to draw complex images, but this may be the first example we’ve seen where everything was done in software. This digital version doesn’t need to follow the traditional “rules”, but we appreciate that [Ben] stuck to them anyway. Incidentally this isn’t the first Etch a Sketch TV conversion to grace these pages, though to be fair, the other project took a radically different approach.

Continue reading “TV Turned Automatic Etch A Sketch With Raspberry Pi”

Small Spotify Remote Broadens Musical Horizons

When was the last time you tried listening to a new genre of music, or even explored a sub-genre of something you already like? That’s what we thought. It’s good to listen to other stuff once in a while and remind ourselves that there’s a whole lot of music out there, and our tastes are probably not all that diverse. As a reminder, [sorghum] made a spiffy little Spotify remote that can cruise through the musical taxonomy that is Every Noise at Once and control any Spotify-enabled device.

There’s a lot to like about this little remote, which is based upon a LilyGo TTGO ESP32 board with on-board display. The circuitry is basically that and a rotary encoder plus a tiny LiPo battery. Can we talk about the finish on those prints? Yes, those are both printed enclosures. Getting that buttery smooth finish took two grits of wet/dry sandpaper plus nine grits of polishing cloths.

As you can see in the brief demo after the break, there are several ways to discover new music. [sorghum] can surf through all kinds of Japanese music for example, or surf by the genre’s ending word and listen to metalcore, deathcore, and grindcore from all over the globe. For extra fun, there’s a genre-ending randomizer so you can discover just how many forms of *core there are.

Want everyone in the room to know what you’re listening to? Behold the Spotify split-flap display.

Continue reading “Small Spotify Remote Broadens Musical Horizons”

Parking Assistant Helps Back Up The Car Without Going Too Far

Sure, [Ty Palowski] could have just hung a tennis ball from the ceiling, but that would mean getting on a ladder, testing the studfinder on himself before locating a ceiling joist, and so on. Bo-ring. Now that he finally has a garage, he’s not going to fill it with junk, no! He’s going to park a big ol’ Jeep in it. Backwards.

The previous owner was kind enough to leave a workbench in the rear of the garage, which [Ty] has already made his own. To make sure that he never hits the workbench while backing into the garage, [Ty] made an adorable stoplight to help gauge the distance to it. Green mean’s he’s good, yellow means he should be braking, and red of course means stop in the name of power tools.

Inside the light is an Arduino Nano, which reads from the ultrasonic sensor mounted underneath the enclosure and lights up the appropriate LED depending on the car’s distance. All [Ty] has to do is set the distance that makes the red light come on, which he can do with the rotary encoder on the side and confirm on the OLED. The distance for yellow and green are automatically set from red — the yellow range begins 24″ past red, and green is another 48″ past yellow. Floor it past the break to watch the build video.

The humble North American traffic signal is widely recognized, so it’s a good approach for all kinds of applications. Teach your children well: start them young with a visual indicator of when it’s okay to get out of bed in the morning.

Continue reading “Parking Assistant Helps Back Up The Car Without Going Too Far”

Magnum Opus Keyboardus, Or Build Ad Infinitum?

It happens to pretty much everyone who gets into keyboards. No commercial keyboard can meet all your needs, so you start building them. Use them a while, find problems, build a new keyboard to address them. Pretty soon you think you have enough user experience to design the perfect keeb — the be-all, end-all magnum opus clacker you can take to the grave. This time, it happened to [aydenvis]. We must say, the result is quite nice. But will it still be perfect in six months?

As you might expect, this board uses an Arduino Pro Micro. We can’t say for sure, but it looks like [aydenvis] created a socket with a second Pro Micro board populated only with female header. That’s definitely a cool idea in case the board fails. It also has two rotary encoders and a pair of toggle switches to switch controller and secondary designations between the PCBs.

We like the philosophy at play in this 36-key ‘board that states that prime ergonomics come when each finger must only travel one key distance from the home row. This of course requires programming layers of functionality into the firmware, which is easy enough to set up, but can be tricky to memorize. One thing that will help is the color-coded RGB underglow, which we’re going to call sandwich glow because it is emanating from the middle of a stacked pair of PCBs floating on 7 mm standoffs. We only wish we could hear how loudly those jade Kailh choc switches can clack. The board files are up on GitHub, so we may just have to make our own.

Indeed, many keebs we see use a Pro Micro or two, but here’s a tasty split that runs on a Raspberry Pi Zero W.

Via reddit

40% Keyboard Build Is 100% Open Source

[Blake]’s interest in building keyboards happened naturally enough — he was looking for a new project to work on and fell into the treasure chest that is the mechanical keyboard community. It sounds like he hasn’t built anything but keyboards since then, and we can absolutely relate.

This tidy 40% ortholinear is [Blake]’s third build, not including macro keebs. It’s based on an open source case and plate from Thingiverse, and uses an Arduino Pro Micro running the popular QMK firmware to read input from 47 Gateron blues and a rotary encoder.

We particularly like the double rainbow ribbon cable wiring method [Blake] used to connect each row and column to the controller. It looks beautiful, yes, but it’s also a great way to maintain sanity while programming and troubleshooting.

Keyboard builds can look daunting, even at 40% of standard size. But as [Blake] discovered, there are some really good guides out there with fantastic tips for hand-wiring in small spaces. And now there is another well-written guide with clear pictures to point to.

Looking to split from the standard rectangle form factor but don’t know what to go with? Divine your next clacker with this split keyboard finder.

Thanks for the tip, [jrdsgl]!

Ergo Keyboard Build Issue Becomes Crystal Clear

Somewhere between the onset of annoying hand pain and the feeling of worn-out, mushy switches, [sinbeard]’s keyboard dissatisfaction came to a head. He decided it was time to slip into something bit more ergonomic and settled on building an Iris — a small split keeb with an ortholinear (non-staggered) key arrangement.

The Iris is open source and uses an on-board controller, so you can have the boards fabbed and do a lot of SMD soldering, or get a pair of PCBs with all of that already done. [sinbeard] went the latter route with this build, but there’s still plenty of soldering and assembly to do before it’s time to start clackin’, such as the TRRS jacks, the rotary encoders, and of course, all the switches. It’s a great way for people to get their feet wet when it comes to building keyboards.

Everything went according to plan until it was time to flash the firmware and it didn’t respond. It’s worth noting that both of the Iris PCBs are the same, and both are fully populated. This is both good and bad.

It’s bad you have two on-board microcontrollers and their crystals to worry about instead of one. It’s good because there’s a USB port on both sides so you can plug in whichever side you prefer, and this comes in mighty handy if you have to troubleshoot.

When one side’s underglow lit up but not the other, [sinbeard] busted out the ISP programmer. But in the end, he found the problem — a dent in the crystal — by staring at the board. A cheap replacement part and a little hot air rework action was all it took to get this Iris to bloom.

Want to build a keyboard but need a few more keys? Check out the dactyl and the ErgoDox.

Spoofing An Analog Rotary Knob With An ATtiny, And Vampiric Power

[Mitxela]’s repair of a Roland JV-1080 (a rack-mounted 90s-era synthesizer) sounds simple: replace a broken rotary encoder on the front panel. It turned out to be anything but simple, since the part in question is not today’s idea of a standard rotary encoder at all. The JV-1080 uses some kind of rotary pulse switch, which has three outputs (one for each direction, and one for pushing the knob in like a button.) Turn the knob in one direction, and one of the output wires is briefly shorted to ground with every detent. Turn it the other way, and the same happens on the other output wire. This is the part that needed a replacement.

The finished unit uses a modern rotary encoder and microcontroller in place of the original part, and implements a few tricks to power it.

Rather than track down a source for the broken part, [Mitxela] opted to replace it with a modern rotary encoder combined with an ATtiny85 microcontroller to make it act like something the JV-1080 understands and expects. There was an additional wrinkle, however. The original rotary pulse switch is an entirely passive device, and lives at the end of a four-conductor cable with no power provided on it. How could the ATtiny85 be powered without resorting to running a wire to a DC voltage supply somewhere? Success was had, but it did take some finessing.

For the power, it turns out that the signal wires are weakly pulled up to +5 V and [Mitxela] used that for a power supply to the microcontroller. Still, by itself that wasn’t enough, because the ATtiny85 can easily consume more current than the weak pullups can source. We really recommend reading all the details in [Mitxela]’s writeup, but the short version is that the ATtiny85 does two things.

First, it minimizes its power usage by spending most of its time in sleep mode (consuming barely any power at all) and uses an interrupt to wake up just long enough to handle knob activity. Second, the trickle of power from the weak pullups doesn’t feed the ATtiny directly. It charges a 100 uF capacitor through a diode, and that is what keeps the microcontroller from browning out during its brief spurts of activity. Even better, after browsing the datasheet for the ATtiny, [Mitxela] saw it was possible to use the built-in ESD protection diodes for this purpose instead of adding a separate component.

It’s a neat trick and makes for a very compact package. Visit the project’s GitHub repository to dive into the nitty gritty. In the end, a single assembly at the end of a 4-wire connector acts just like the original passive component, no extra wires or hardware modifications needed.

When opening older hardware it’s never quite certain what will be found on the inside. But at least [Mitxela]’s repair duties on this synth didn’t end up with him tripping out on LSD.