Cablecam Is An Exercise In System Integration

Drones have become the standard for moving aerial camera platforms, but another option that sees use in the professional world are cable cameras. As an exercise in integrating mechanics, electronics, and software, [maxipalay] created his own Cablecam.

Cablecam is build around a pair of machined wood plates, with some pulleys and motor reduction gearing between them. A brushless hobby motor moves the platform along the rope/cable, driven a drone ESC. Since the ESC doesn’t have a reverse function, [maxipalay] used four relays controlled by an Arduino to swap around the connections of two of the motor wires to reverse direction. The main onboard controller is a Raspberry Pi, connected to a camera module mounted on a two-axis gimbal for stabilization. A GPS module was also added for positioning information on long cables.

The base station is built around an Nvidia Jetson Nano connected to a 7″ screen mounted in a plastic case. Video, telemetry and control signals are communicated using the open-source Wifibroadcast protocol. This uses off-the-shelf WiFi hardware in connectionless mode to broadcast UDP packets, and avoids the lengthy WiFi reconnection process every time a connection drops out. The motion of Cablecam can be controlled manually using a potentiometer on the control station, or use the machine vision capabilities of the Jetson to automatically track and follow people.

We’ve seen several cable robots over the years, including a solar-powered sensor platform that resembles a sloth.

Avoid Awkward Video Conference Situations With PIR And Arduino

Working from home with regular video meetings has its challenges, especially if you add kids to the mix. To help avoid embarrassing situations, [Charitha Jayaweera] created Present!, a USB device to automatically turn of your camera and microphone if you suddenly need to leave your computer to maintain domestic order.

Present consists of just a PIR sensor and Arduino in a 3D printed enclosure to snap onto your monitor. When the PIR sensor no longer detects someone in range, it sends a notification over serial to a python script running on the PC to switch off the camera and microphone on Zoom (or another app). It can optionally turn these back on when you are seated again. The cheap HC-SR501 PIR module’s range can also be adjusted with a trimpot for your specific scenario. It should also be possible to shrink the device to the size of the PIR module, with a small custom PCB or one of the many tiny Arduino compatible dev boards.

For quick manual muting, check out the giant 3D printed mute button. Present was an entry into the Work from Home Challenge, part of the 2021 Hackaday Prize.

Finding Fractals In The 1930’s

The mesmerizing properties of fractals are surprising as their visual complexity often arises from simple equations. [CodeParade] set out to show how simple a fractal is by creating them using technology from the 1930s. The basic idea is based on projectors and cameras, which were both readily available and widely used in television (CRT projectors were in theaters by 1938, though they weren’t in color until the 1950s).

By projecting two overlapping images on the wall, pointing a camera at the resulting image, and then feeding it back into the projectors, you get some beautiful fractals. [CodeParade] doesn’t have a projector, much less two. So he did what any hacker might do and came up with a clever workaround. He made a simple app that “projects” onto his monitor and all he has to do is point an external webcam at the screen. The resulting analog fractals are quite beautiful and tactile. Rather than tweaking a variable and recompiling, you simply just add a finger or move the camera to introduce new noise that quickly becomes signal.

Better yet, there’s a web version that you can play around with right now. For more fractals implemented in hardware rather than software, there’s this FPGA with a VHDL Mandelbrot set we covered.

Continue reading “Finding Fractals In The 1930’s”

This Horrifying Robot Is Here To Teach You A Lesson

No, despite what it might look like, this isn’t some early Halloween project. The creepy creation before you is actually a tongue-in-cheek “robot” created by the prolific [Nick Bild], a topical statement about companies asking their remote workers to come back into the office now that COVID-19 restrictions are being lifted. Why commute every day when this ultra realistic avatar can sit in for you?

OK, so maybe it’s not the most impressive humanoid creation to ever grace the pages of Hackaday. But if you’re looking to spin up a simple telepresence system, you could do worse than browsing through the Python source code [Nick] has provided. Using a Raspberry Pi 4, a webcam, and a microphone, his client-server architecture combines everything the bot sees and hears into a simple page that can be remotely accessed with a web browser.

Naturally this work from home (WFH) bot wouldn’t be much good if it was just a one-way street, so [Nick] has also added a loudspeaker that replays whatever he says on the client side. To prevent a feedback loop, his software includes a function that toggles which direction the audio stream goes in by passing the appropriate commands to the bot over SSH; a neat trick to keep in mind for your own, less nightmarish, creations.

If you’re looking for something a bit more capable and have some cardboard laying around, this DIY telepresence mount for your phone might be a good place to start.

Continue reading “This Horrifying Robot Is Here To Teach You A Lesson”

Video De-shaker Software Measures Linear Rail Quality

Here’s an interesting experiment that attempts to measure the quality of a linear rail by using a form of visual odometry, accomplished by mounting a camera on the rail and analyzing the video with open-source software usually used to stabilize shaky video footage. No linear rail is perfect, and it should be possible to measure the degree of imperfection by recording video footage while the camera moves down the length of the rail, and analyzing the result. Imperfections in the rail should cause the video to sway a proportional amount, which would allow one to characterize the rail’s quality.

To test this idea, [Saulius] attached a high-definition camera to a linear rail, pointed the camera towards a high-contrast textured pattern (making the resulting video easier to analyze), and recorded video while moving the camera across the rail at a fixed speed. The resulting video gets fed into the Deshaker plugin for VirtualDub, of which the important part is the deshaker.log file, which contains X, Y, rotate, and zoom correction values required to stabilize the video. [Saulius] used these values to create a graph characterizing the linear rail’s quality.

It’s a clever proof of concept, especially in how it uses no special tools and leverages a video stabilizing algorithm in an unusual way. However, the results aren’t exactly easy to turn into concrete, real-world measurements. Turning image results into micrometers is a matter of counting pixels, and for this task video stabilizing is an imperfect tool, since the algorithm prioritizes visual results instead of absolute measurements. Still, it’s an interesting experiment, and perfectly capable of measuring rail quality in a relative sense. Can’t help but be a bit curious about how it would profile something like these cardboard CNC modules.

Big Spinning Disk Makes A Small Color Video Display

Believe it or not, the Mickey Mouse clip used for this demonstration is actually in the public domain.

The earliest televisions used a spinning disk technology called the Nipkow disk, which is exactly what [Science ‘n’ Stuff] recreated with their Arduino-based mechanical color television (video link, also embedded below.) The device reads video and audio from an SD card, and displays the video using a precisely-timed RGB LED visible through a perforated spinning disk. The persistence of vision effect results in a video that is small, relative to the size of the disk, but perfectly watchable. A twist is that the video is in color!

A Nipkow disk is a fairly simple and electromechanical device that relies on timing; something a modern microcontroller and RGB LED is perfectly capable of delivering. In this device, the holes in the disk create 32 vertical scanlines with 96 “pixels” making up each of those lines. Spinning disk technology was always limited to being monochromatic, but in this implementation, each “pixel” is given its own unique color by adjusting the RGB LED accordingly.

The first video shows off the device and demonstrates it working; note that it may look like there are multiple little screens, but the center one can be thought of as the “true” display with the others essentially being artifacts due to light leakage. If you’re interested in the nuts and bolts of exactly how a Nipkow disk works, then the second video is what you’ll be more interested in, because it goes through all the details of exactly how everything functions.

Another neat thing about Nipkow disks is that image acquisition is really not much more complex than image display.

[via Arduino Blog]

Continue reading “Big Spinning Disk Makes A Small Color Video Display”

VGA From Scratch On A Homebrew 8-bit Computer

[James Sharman] has built an impressive 8-bit homebrew computer. Based on TTL logic chips, it has a pipelined design which makes it capable of Commodore-level computing, but [James] hasn’t quite finished everything yet. While it is currently built on its own custom PCB, it has a limiting LCD display which isn’t up to the standards of the rest of the build. To resolve this issue, he decided to implement VGA from scratch.

This isn’t a bit-bang VGA implementation, either. He plans for full resolution (640×480) which will push the limits of his hardware. He also sets goals of a 24-bit DAC which will allow for millions of colors, the ability to use sprites, and hardware scrolling. Since he’s doing all of this from scratch, the plan is to keep it as simple as possible and make gradual improvements to the build as he goes. To that end, the first iteration uses a single latching chip with some other passive components. After adding some code to the CPU to support the new video style, [James] is able to display an image on his monitor.

While the image of the parrot he’s displaying isn’t exactly perfect yet, it’s a great start for his build and he does plan to make improvements to it in future videos. We’d say he’s well on his way to reproducing a full 8-bit retrocomputer. Although VGA is long outdated for modern computers, the standard is straightforward to implement and limited versions can even be done with very small microcontrollers.

Thanks to [BaldPower] for the tip!

Continue reading “VGA From Scratch On A Homebrew 8-bit Computer”