Modular Vacuum Table Custom-Fits The Parts

March 31, 2024 by Donald Papp 3 Comments

[enhydra] needed to modify a bunch of side inserts from some cheap ABS enclosures, and to save time and effort, he created a simple vacuum table with swappable inserts to precisely fit the parts. Suction is provided by a shop vacuum (plugged in near the bottom in the photo above) and it worked very well! Sealing and gaskets weren’t even required.

A vacuum table provides a way to hold workpieces flat and secure while a CNC machine does its thing, and because no clamps are involved, it can really speed up repetitive work. [enhydra]’s solution combines a vacuum table with a jig that ensures every rectangular piece is held exactly where the machine expects it to be, making the whole process of modifying multiple units significantly more efficient.

The whole thing — vacuum table and modular top — was straightforward to CNC cut out of what looks like particle board and worked as-is, no added gaskets or seals required, making this a very economical solution.

Vacuum tables can be pretty versatile and applied in more than one way, so keep that in mind the next time you’re wondering how best to approach a workshop problem. We’ve seen a well-engineered table used to speed up PCB milling, and we’ve also seen a DIY vacuum table combined with a heat gun and plastic plates from the dollar store make a bare-bones thermoforming rig.

Playing Chess Against Your Printer, With PostScript

March 30, 2024 by Donald Papp 11 Comments

Can you play chess against your printer? The answer will soon be yes, and it’s thanks to [Nicolas Seriot]’s PSChess. It’s a chess engine implemented in PostScript, of all things. It’s entirely working except for one last hurdle, but more on that in a moment.

What’s it like to play PSChess? Currently, one uses a PostScript interpreter (such as GhostScript) to run it, much like one would use the Python interpreter to run Python code. The user inputs moves by typing in commands like d2d4 (representing a piece’s source coordinate and a destination coordinate on the 2D board). Then the program makes a move, and outputs an updated board state to both the console and a PDF document. Then it’s the user’s turn again, and so on until somebody loses.

The chess parts are all working, but there’s one last feature in progress. The final step of the project is to enable PSChess to be run directly on a printer instead of using GhostScript as the interpreter. Intrigued? You can find the code at the project’s GitHub repository.

So why PostScript? While it is a Turing-complete stack-based interpreted language, it was never intended to be used directly by humans. There are no meaningful development tools to speak of. Nevertheless, [Nicolas] finds PostScript an appealing tool for programming projects and provides tips and techniques for like-minded folks. One of the appeals is working within constraints to solve a problem, just like implementing a chess engine in only 4k, or draw poker in 10 lines of BASIC.

Experiencing Visual Deficits And Their Impact On Daily Life, With VR

March 29, 2024 by Donald Papp 14 Comments

Researchers presented an interesting project at the 2024 IEEE Conference on Virtual Reality and 3D User Interfaces: it uses VR and eye tracking to simulate visual deficits such as macular degeneration, diabetic retinopathy, and other visual diseases and impairments.

Typical labels and pill bottles can be shockingly inaccessible to a variety of common visual deficits.

VR offers a unique method of allowing people to experience the impact of living with such conditions, a point driven home particularly well by having the user see for themselves the effect on simple real-world tasks such as choosing a pill bottle, or picking up a mug. Conditions like macular degeneration (which causes loss of central vision) are more accurately simulated by using eye tracking, a technology much more mature nowadays than it was even just a few years ago.

The abstract for the presentation is available here, and if you have some time be sure to check out the main index for all of the VR research demos because there are some neat ones there, including a method of manipulating a user’s perception of the shape of the ground under their feet by electrically-stimulating the tendons of the ankle.

Eye tracking is in a few consumer VR products nowadays, but it’s also perfectly feasible to roll your own in a surprisingly slick way. It’s even been used on jumping spiders to gain insights into the fascinating and surprisingly deep perceptual reality these creatures inhabit.

Is Your Mental Model Of Bash Pipelines Wrong?

March 28, 2024 by Donald Papp 11 Comments

[Michael Lynch] encountered a strange situation. Why was compiling then running his program nearly 10x faster than just running the program by itself? [Michael] ran into this issue while benchmarking a programming project, pared it down to its essentials for repeatability and analysis, and discovered it highlighted an incorrect mental model of how bash pipelines worked.

Here’s the situation. The first thing [Michael]’s pared-down program does is start a timer. Then it simply reads and counts some bytes from stdin, then prints out how long it took for that to happen. When running the test program in the following way, it takes about 13 microseconds.

$ echo '00010203040506070809' | xxd -r -p | zig build run -Doptimize=ReleaseFast
bytes: 10
execution time: 13.549µs

When running the (already-compiled) program directly, execution time swells to 162 microseconds.

$ echo '00010203040506070809' | xxd -r -p | ./zig-out/bin/count-bytes
bytes: 10
execution time: 162.195µs

Again, the only difference between zig build run and ./zig-out/bin/count-bytes is that the first compiles the code, then immediately runs it. The second simply runs the compiled program. Continue reading “Is Your Mental Model Of Bash Pipelines Wrong?” →

Clever E-Ink Driver Does 32 Levels Of Grey, Avoids Update Flicker, And More

March 23, 2024 by Donald Papp 13 Comments

There’s a lot to like about E-Ink displays, and you might be about to like them even more with [antirez]’s MicroPython driver for the Badger 2040 (or any display based on the UC8151 / IL0373) because it brings all kinds of useful features to your next project.

E-Ink displays are great. They are high contrast, daylight-readable, and require zero power to maintain a displayed image. But a few things come with the territory: displays have slow refresh rates compared to other display types, expect flickering during screen changes, and the displays are monochrome. [Antirez]’s new driver not only provides a MicroPython interface but goes in some fantastic directions that challenge those usual drawbacks.

Probably the most striking is the ability to display greyscale images without relying on dithering, which means the results avoid the charmingly gritty look of old-school dithering. Dithering has its place, but it’s not always the best choice, so options are great.

Similarly, display flicker may be a small price to pay for some, but if the obvious flicker is too boorish and crude-looking one can use an anti-flicker refresh mode that greatly limits flickering at the cost of update speed. Over time some image ghosting will accumulate which necessitates an occasional whole-screen refresh, but the effect is overall much nicer when updating something like a clock face.

How is this all done? It turns out that the controller chips for these displays are highly configurable, and it’s possible to do much more than simply drive the display in known-good and completely approved modes. It’s also entirely possible to permanently damage one’s display by doing so. Part of what makes [antirez]’s work so appealing is that he has already done the work finding workable configurations.

His driver is designed using computed LUTs (look-up tables) that make using and exploring alternative refresh modes easy and efficient, invaluable for exploring the capabilities of a patented, poorly documented technology like E-Paper displays.

We’ve seen the Badger 2040 E-Ink display in a teapot timer and a custom macropad, and [antirez]’s uc8151_micropython project is a fantastic step forward. And don’t miss another of [antirez]’s clever microcontroller hacks: playing audio without a DAC.

AI Image Generation Meets Virtual Dress Up

March 22, 2024 by Donald Papp 17 Comments

Image generators have really taken off thanks to machine learning, and all kinds of new ideas have been turned on in people’s heads as a result. OOTDiffusion is one such project, its job being to allow virtual try-ons of clothing by combining a picture of a person and an item of clothing, and doing so in a coherent way.

A model sporting a 2021 Remoticon shirt.

When it comes to AI image generators, maintaining consistency of a particular subject in a picture while changing or combining other parts of the image isn’t a trivial task. (If you’re unfamiliar with the basics of how diffusion-type AI image generators work, we have you covered.)

Virtual try-on of clothing is not a new idea, but it’s also far from being a completely solved problem. It’s easy to feed a system high-quality images of people and clothing and ask it to combine them, but the outputs rarely emerge with all their limbs intact, figuratively speaking.

OOTDiffusion addresses the two big challenges in this area: making sure the outputs look natural and realistic, and preserving as much of the garment’s appearance and qualities as possible in the process.

It seems to to a very good job, and you can try it for yourself in the online demo. Check out the research paper for more details, and the GitHub repository provides all the code if you’d like to get a little more hands-on.

Video Poker Takes Your Money In 10 Lines Of BASIC

March 21, 2024 by Donald Papp 14 Comments

It wasn’t easy, but [D. Scott Williamson] succeeded in implementing Jacks or Better Video Poker in 10 lines of BASIC, complete with flashing light and sound! Each round, one places a bet then plays a hand of 5-card draw, hoping to end up with Jacks or better.

This program is [Scott]’s entry into the 2024 BASIC 10 Liner Contest, which at this writing has concluded submissions and expects to announce results on April 6th 2024. Contestants may choose any 8-bit computer system BASIC, and must implement their program within ten lines of code (classically limited to 80 characters per line, but there are different categories with different constraints on line width.)

10 lines of BASIC is truly an exercise in information density.

We’ve seen impressive 10-line BASIC programs before, like this re-implementation of the E.T. video game. (Fun fact: while considered one of the worst video games of all time, there’s a compelling case to be made that while it was a flop, it was ahead of its time and mostly just misunderstood.)

These programs don’t look much like the typical BASIC programs many of us remember. They are exercises in information density, where every character counts. So we’re delighted to see [Scott] also provides a version of his code formatted and commented for better readability, and a logical overview that steps through each line.

He spends a little time talking about the various challenges, as well. For example, hand ranking required a clever solution. IF…THEN conditionals would rapidly consume the limited lines of code, so hands are ranked programmatically. The 52-card deck is also simulated, rather than simply generating random cards on the fly.

The result looks great, and you can watch it in action in the video, just under the page break. If this sort of challenge tweaks your interest, there’s plenty of time to get started on next year’s BASIC 10 Liner Contest. Fire up those emulators!

Continue reading “Video Poker Takes Your Money In 10 Lines Of BASIC” →