TechyMagThings

Sometimes you see a project just staring at you with proverbial puppy dog eyes and you just cannot look away. In the case of a once rather nice Sony TV it was the smooth 32″ Trinitron CRT that gave [Happychoice] that look when he came across it along the side of the road. Naturally he had to beg the owner of the junkyard to please let him adopt the pupp^Wjunked TV and attempted an ill-advised repair.

Some later sleuthing revealed that this poor TV had been sitting on the side of that road for at least six years, exposed to the worst that the Italian weather and local fauna could do to it, so it was no surprise that all he got out of it even after cleaning and some repairs was a sad triple-blink of the power LED. This indicated that something on the control board was very unhappy about the status of the power supply.

Over the course of a few months this project went correspondingly from careful optimism down to the depths of depression, through the fields of bargaining and into the blue skies of acceptance of a likely far more involved repair session than originally assumed. That said, the CRT itself looks to be in pretty good nick, as do the PCBs barring the few sketchy resistors that already got replaced.

We would like to congratulate [Happychoice] on the acquisition of a fun new repair project and wish him all the luck on bringing this beast of a TV back to life.

For whatever reason, [Jeremy] wants to photograph bees in flight. This is one of those things that doesn’t seem that hard until you try to do it. He’s got the mechanical part that can move the camera as fast as the bee flies. But you still have to point the camera correctly. He considered quite a few methods of acquiring and tracking the bee, but he finally settled on a stereo camera. His requirements also made the camera design challenging. In particular, the bees move fast enough that things like USB transmission times become significant. You can see his solution in the video below.

[Jeremy] does a great job explaining all the tradeoffs between frame rate, resolution, focal length, and other optical issues. Of course, he also wanted a global shutter sensor. Rolling shutter cameras scan row-by-row, creating the well-known “jello effect”. Global shutters capture all pixels at once. That also removes any uncertainty as to “when” the shutter fired.

All of this is, of course, doubled when you are trying to use two synchronized cameras. Tracking a tiny high-speed flying object isn’t easy. By the end of the video, we don’t get to see bee videos yet, but we feel like he will get there. Stay tuned.

We’ve seen high-performance stereo video systems before. While global shutter cameras are not terribly common, they aren’t that exotic anymore, either.

Paper as a substrate for electronic circuits is not very common, but promising for flexible circuits with low cost and easy recyclability. That said, paper is not an easy material to work with when printing traces, as the cellulose material is both absorbent and irregular, limiting the resolution and accuracy of so-called papertronics. Even when using higher-quality paper with wax-based masks this resulted in poor resolution issues, so [Zahra Rafiee] et al. opted to approach the problem from the other direction, by using hydrophobic parchment paper as the base combined with a laser.

The nice thing about the inks used with papertronics that they aren’t just traces, but can also be functional elements like resistors, which is also demonstrated in the paper. The channels for the inks are created using a 50 Watt CO₂ laser, which etches away the silicone coating on the parchment paper. The achieved resolution in the article is around 250 µm for line widths and 300 µm line spacing, which is much better than that for wax-based alternatives.

Providing conductivity in the inks was PEDOT:PSS, which, when mixed with dimethyl sulfoxide (DMSO), creates resistors. Capacitors can be printed by creating interlocking PEDOT:PSS ‘fingers’, with a Poly Vinyl Alcohol (PVA) based gel overlaid as electrolyte. These combinations were used to create RC low- and high-pass filters.

The degradation of these papertronic circuits was also tested, with them buried in soil under typical conditions. Only the silicone coating was rather immune to degradation. Since silicone is considered chemically and biologically inert, it’s claimed to not be an issue. For situations where such easy decomposition is not desirable, encapsulation with polydimethylsiloxane (PDMS) is offered as an option.

Avian Visitors is a lovely project by [Teddy Warner] that uses a Raspberry Pi and microphone to keep track of which birds have been visiting your home, and creates a colorful illustration of recent visitors on top of it all.

It reports on a web interface of its own making, but what really takes things to a new level is an optional, stylish E-Ink panel that shows the last 24 hours’ worth of visitors at a glance in a collage.

The key to identification is BirdNET (GitHub here), a deep learning classifier from Cornell that can reliably identify and classify more than 11,000 species worldwide based on sound alone.

Based on that information, the system pulls bird images from a reference set for the region and creates a collage representing the breadth and frequency of visitors in a single image. The larger the image of a bird, the more frequently it was heard.

That’s a cool project, but [Teddy] took things one step further by setting up a color E-Ink display to show a running summary of all the avian visitors the system identifies. [Teddy] has a knack for leveraging projects into wall-mounted art, as we saw with his generative art wall plotter.

Got ideas of your own? Avian Visitors even has options for sending the latest detection to Home Assistant or over MQTT, allowing automation triggers based on specific bird species. If you decide to try it out and put your own spin on it, be sure to let us know by sending us a tip!

The GitHub repository for Avian Visitors has everything you need to get set up, and the basic system needs little more than a Raspberry Pi and a USB microphone. There’s a build video embedded just below, so give it a shot if you want to get a better idea of what birds come visiting.

If you’ve ever worked with produce, you might know about grading. In addition to deciding if, say, a strawberry is good or not, they also have to sort them by color. Turns out, you don’t care if one package of berries is a bit redder than another, but you do care if one package has too much color variation. [Pmalfa31] applied an ESP32 and machine learning to grading tomatoes.

The system knows in advance if you are processing standard tomatoes or cherry tomatoes and uses two different sets of learned data depending on which you select. The program receives raw data from an optical sensor and then processes it to remove empty belt images, compute statistical information, and group readings for a single fruit together.

One thing we liked was the program’s heuristic checking of validity. It knows the approximate size of the tomato, so the code notes if the fruit seems too big for a cherry tomato or too small for a standard tomato. This reduces, but doesn’t eliminate, miscategorizations.

The code is a stack hog, so the program has to request a much larger stack. If you want to try it yourself, there is a simulator on the web available, so you don’t even need any hardware or tomatoes to try it.

Computers have lots of uses on a modern farm.

If you’re water cooling a PC, it’s generally accepted that you need some interface between the coolant and the chips — a water block of copper or aluminum that carries the heat-removing fluid. What if you just…didn’t? That’s what [TrashBench] asked with his direct water cooling experiment. Instead of integrated pump or copper water block, he just epoxied a 3D printed pipe fitting onto his bare GPU and CPU.

The results are interesting: while the directly-cooled GPU outperforms the professional system by a decent margin, the same technique fails when applied to the CPU. It also leaks and nearly ruins his hardware, but those are the risks you take when doing mad science, and it’s nothing more epoxy can’t fix. In any case, the fact that directly exposing chips to liquid can cool them down isn’t exactly a revelation. People have been dunking computers in oil for years, but the fact that he sees such a difference between CPU and GPU is quite interesting. [TrashBench] has his own theory in the video, but what do you think is going on here?

In any case, if he continues his direct cooling experiments he’s still going to need a radiator, and if we may be so bold, we would like to recommend a giant metal snake.

Sandboxing a Linux process usually means spending a lot of effort deciding what it isn’t allowed to see. You might put it in a mount namespace, bind-mount a few directories into place, hide some others, add a chroot, and generally construct a carefully restricted version of the filesystem. But a new Linux kernel feature is about to change all of that. Instead of carefully hiding most of the filesystem, why not just take the filesystem away?

That’s essentially the idea behind FailFS, a tiny pseudo-filesystem expected to land in Linux 7.3. As the name suggests, it doesn’t do very much. In fact, that’s the point: every operation that reaches FailFS returns EOPNOTSUPP, meaning “operation not supported.”

The interesting bit is what happens when a process uses FailFS as its root or current working directory. At that point, normal pathname lookup essentially ceases to work. Absolute paths fail. Absolute symbolic links fail. Relative paths using the normal current-directory mechanism fail. If the application tries to open /etc/passwd, there simply isn’t a useful /etc to find.

Instead, the process has to start filesystem operations from an explicit file descriptor it already owns. For example, a sandbox manager could open a directory, hand that descriptor to the application, and the application could access files below it using calls such as openat(). Anything not reachable from one of those deliberately supplied descriptors might as well not exist.

Instead of starting with an entire filesystem and constructing rules that say, “not that, not that, not that,” you start with nothing and explicitly hand over the pieces the program needs.

There are some interesting consequences. At present, putting a process completely inside FailFS also prevents it from launching ordinary dynamically linked executables. ELF binaries generally specify their dynamic loader using an absolute pathname such as /lib64/ld-linux-x86-64.so.2. Absolute paths don’t work, so neither does the loader.

FailFS also has an interesting sibling called NULLFS, introduced earlier. NULLFS is another deliberately useless filesystem, but it behaves slightly differently: it contains a permanently empty directory and failed lookups return ENOENT, as though the requested file simply doesn’t exist. It was originally introduced to provide an immutable bottom layer beneath the real root filesystem and make operations such as pivot_root() cleaner.

Neither replaces all the other pieces needed for a secure sandbox. Processes still have system calls, networking, IPC, inherited descriptors, and plenty of other ways to cause trouble. But for controlling filesystem access, FailFS has a nice, simple philosophy.

Of course, if your file system is unwritable, that works, too.