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?
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.
Companies like Google and Microsoft have been investing heavily in the concept of cloud gaming, where a player uses their computer or a mobile device to stream the video feed of a game that’s running on powerful machine tucked away in a data center somewhere. With this technology you can play the latest and greatest titles, even if the device you’re using doesn’t have the processing power to run it locally.
Considering the Switch is already a portable system, it’s not too surprising Nintendo doesn’t seem interested in the technology. But that didn’t stop [Stan Dmitriev] from doing a bit of experimentation on his own. With little more than a Raspberry Pi 4 and Trinket M0, he’s demonstrated that users can remotely interact with the Switch well enough to play games in real time.
The setup is fairly straightforward. A cheap HDMI capture device is used to grab the video from the Nintendo Switch dock, which is then streamed out to web with the help of the Pi’s hardware video encoder. Input from the user is sent over the Pi’s UART to the Trinket, which itself is running a firmware specifically developed for mimicking Nintendo Switch controllers. With so many elements involved, naturally some latency comes into play. The roughly 100 millisecond delay [Stan] is reporting isn’t exactly ideal for fast-paced gaming, but is certainly adequate for more relaxed titles.
On the software side of things, the project is using a SDK developed by [Stan]’s employer SurrogateTV. Right now you need to apply if you want to get your game or other interactive gadget up on the service, though he says it will be opened up to the public next year. But even without all the details, we’ve got a clear idea of how both the video capture and user input sides of the equation are being handled. For personal use, all you’d really need to do is put together a simple web interface to tie it all together.
Running a camera studio is a complicated affair from pretty much every angle. Not only is the camera gear expensive but the rest of the studio setup takes care and attention down to the lighting as well. When adding multiple cameras to the mix, like for a television studio, the level of complexity increases exponentially. It’s great to have a few things that simplify the experience of running all of this equipment too, without the solution itself causing more problems than it solves, like these network-operated Raspberry Pi-powered tally lights.
A tally light is the light on a camera that lets the person being recorded know which camera is currently in use. Networking them all together often requires complex wiring or at least some sort of networking solution, which is what this particular build uses. However, the lights are controlled directly over HTTP rather than using a separate application which might need a port open on a firewall or router, which not only simplifies their use but doesn’t decrease network security.
The HTTP interface, plus all of the software and schematics for this build, are available on the project’s GitHub page. We imagine the number of people operating a studio and who are in need of a tally light system to be fairly low, but the project is interesting from a networking point-of-view regardless of application. If you do have a studio like this and are looking for other ways to improve it, we do have a simple teleprompter hack that might be right up your alley.
Since its debut back in 2012 there have been a variety of inventive displays used with the Raspberry Pi. Perhaps you remember the repurposed Motorola phone docks, or you have one of those little displays that plugs into the expansion port. Inevitably the smaller options become disappointing as desktop displays, because while the advert triumphantly shows them sporting a Raspberry Pi OS desktop the reality is almost unusable. Until now.
Unexpectedly its mode of operation is very accessible to the non-Linux guru, because it works through a Python script that takes screenshots of both areas and passes them as a composite to the display. An area the size of the magnified window is drawn around the mouse pointer, allowing it to be easily located on the tiny desktop. It relies on the main display being pushed to the HDMI output, so if the Pi is otherwise headless then its configuration has to be such that it forces HDMI use. The result isn’t something that would help you with the more demanding desktop tasks, but it provides a neat solution to being able to use a Pi desktop on a tiny screen.
If you had an Amiga during the 16-bit home computer era it’s possible that alongside the games and a bit of audio sampling you had selected it because of its impressive video capabilities. In its heyday the Amiga produced broadcast-quality graphics that could even be seen on more than a few TV shows from the late 1980s and early 1990s. It’s fair to say though that the world of TV has moved on since the era of Guru Meditation, and an SD video signal just won’t cut it anymore. With HDMI as today’s connectivity standard, [c0pperdragon] is here to help by way of a handy HDMI upgrade that taps into the digital signals direct from the Amiga’s Denise chip.
At first thought one might imagine that an FPGA would be involved, however instead the signals are brought out via a daughterboard to the expansion header of a Raspberry Pi Zero. Just remove the DENISE display encoder chip and pop in the board with uses a long-pinned machined DIP socket to make the connections. The Pi runs software from the RGBtoHDMI project originally created with the BBC Micro in mind, to render pixel-perfect representations of the Amiga graphics on the Pi’s HDMI output. The caveat is that it runs on the original chipset Amigas and only some models with the enhanced chipset, so it seems Amiga 600 owners are left in the cold. A very low latency is claimed, which should compare favourably with some other solutions to the same problem.
If you ever need to cluster up to 14 Raspberry Pis and an equal number of 2.5 inch hard drives, you might want to look at the Raspberry Pi Server Mark III case from [Ivan Kuleshov]. The original Mark I design came from Thingiverse, but the Mark III is a complete redesign.
The redesign allows for more boards along with a reduction in the number of parts. That takes less plastic and less time to print. The design is also modular, so there should be new components in the future.
[Mark]’s initial attempts relied on Python and the RPI.GPIO library. Unfortunately, the overheads introduced made decoding SENT traffic impossible. Undeterred, [Mark] pressed on, leveraging the pigpio library and its callback function which allowed sampling at up to one microsecond. This was fast enough to read the messages from a LX3302A inductive position sensor that uses the protocol.