A PCB layout is superimposed on a grey grid of hexagonal cells. The PCB traces mostly bend at 120-degree angles, and an integrated circuit's footprint is tilted at an angle matching the grid.

Improving An Autorouter With A Hexagonal Grid

Despite the recent leaps forward in other forms of computer-driven design, the reliability of PCB autorouters remains questionable; on the positive side, though, the lack of massive training data makes them plausible for a determined programmer to implement. For anyone contemplating this undertaking, [James Bowman] recommends a slightly unusual choice: use a hexagonal layout grid.

[James] built his own autorouter in his CuFlow PCB layout program. It takes a fairly straightforward approach: it represents the board as a grid of cells, and uses Lee’s algorithm to find the shortest routes between connected cells. The program initially used a square grid, but a hexagonal grid had a few advantages: in particular, each cell has six equidistant neighbors, rather than four (or eight, if you accept diagonal neighbors at a different distance), which allows denser routing. Because a hexagon more closely approximates a circle than a square, the same minimum-distance rules allow smaller cells, allowing the autorouter to pack more traces into the same space.

While we have previously seen a self-built autorouter, it’s much more common to interface with an external tool. If you start to get into high-speed PCB routing, though, building an autorouter becomes much harder.

Mars Pathfinder: What Really Happened?

You’ve probably heard of Mars Pathfinder, the NASA lander and its Sojourner rover that took up residence on Mars in 1997. At first, all was well, but after a few days, the lander suffered a series of total system resets. A watchdog timer detected a problem and forced reboots. [Vivek Bhageria’s] recent post looks into what happened and the eventual solution.

The root cause was priority inversion. This happens when a lower-priority task holds a resource needed by a higher-priority task and prevents the higher-priority task from executing. In this case, the operating system was VxWorks, but this can happen on any kind of priority scheduling system.

The simplified version is that there were two tasks that each used the same mutex to avoid stepping on each other. The highest priority was a data distribution task. The lowest priority task dealt with meteorology data processing. There was also a medium-priority task that handled bus maintenance.

The failure would occur when the low-priority task had the mutex and lost its time slot before releasing it. The high-priority task would then find it couldn’t take the mutex. However, the low-priority task didn’t get control again because of the medium-priority tasks waiting to run.

In effect, the high-priority task was now waiting on something that couldn’t become available until the lowest-priority task was able to run. That’s priority inversion.

Continue reading “Mars Pathfinder: What Really Happened?” →

Digital Signage In The Browser With Just A Click

There are many ways to display text on a computer screen, but most require at least some manual effort from the user. It’s annoying enough even if you’re dealing with one machine, but it gets even more of a hassle when you’re trying to display something on multiple devices of varying size and capability. That’s where BIGWORDS.PAGE by [SpeakingOfBrad] comes in.

It’s essentially a simple web page you can control via a carefully crafted URL, letting you create all sorts of text displays you can “distribute” to browsers on other devices with a simple link. So, for example, if you wanted to let everyone see what your favorite website is, you need only point the browser on your phone or laptop to https://bigwords.page/#Hackaday. As the image at the top of this post shows, you can also change the font and text colors by adding a few more values.

Continue reading “Digital Signage In The Browser With Just A Click” →

SmallTV Hacking With Surprisingly Little Fuss

We’ve seen the GeekMagic SmallTV line of devices before — these cheap gadgets combine a microcontroller and a display in a little plastic case that can be used to show the time or weather. Powered by either an ESP8266 or an ESP32, the things could easily pass for a hobby build if it wasn’t for their professionally produced enclosures. In fact, we wouldn’t be surprised if GeekMagic lifted the idea from an existing DIY project.

As you might expect we’ve seen several hacks for these devices already, which usually involves replacing the stock firmware. But this latest approach is unique in that you don’t need to mess with the stock software, nor do you need to break out the soldering iron. By leveraging a built-in photo viewer function of the SmallTV [Yongha Kim] shows how you can get the gadget to display pretty much whatever you want.

The trick here is that the image is being generated by a machine on the network, say your desktop or server, and being pushed over to the SmallTV over HTTP. In this example the image is being generated in Python with the Pillow library, and [Yongha] has it showing Claude and Codex usage data, but you could really approach this however you wish.

All you need to do is create a 240×240 image and shoot it over to the device, so you’re free to come up with whatever sort of visuals you’d like. It even supports GIF if you’d like to work animation into it. The content can of course be whatever information you’re interested in showing, and it can be generated by whatever programming language or tool you’re most comfortable with. It’s a fascinating proof of concept, and now that the method has been demonstrated we’re interested to see where the community can take it.

If this all sounds a little too easy for your tastes, don’t worry. There’s a plenty deep rabbit hole you can dive into should you elect to replace the device’s firmware entirely.

Gardening With…OpenSCAD?

Unless it’s automated or using some other form of high-tech trickery, a vegetable garden isn’t exactly the sort of thing you’d expect to see on Hackaday. Be that as it may, the bountiful crop of peppers [Mihai Oltean] grew on the side of his house was done the old fashioned way, with nary a transistor in sight. So what’s the catch?

Well, in this case, it’s more about the journey than the end result. The produce sprouting in [Mihai]’s garden may be common enough, but the method in which he designed the garden itself is worth a closer look. To our knowledge, it’s the first time somebody sat down and wrote out all the code to generate a 3D model of a vertical garden in OpenSCAD.

Usually, we see OpenSCAD used to produce design files for 3D printing or occasionally 2D CNC operations. But that’s not what’s happening here. The goal was to simply plan out how all the parts of the system would come together, and [Mihai] felt comfortable tackling it in the code-centric workflow offered by OpenSCAD. We know the feeling well.

Though the code isn’t necessarily being used to produce parts for manufacture, [Mihai] does bring in a bunch of virtual components to stand in for their corporeal counterparts. We’re partial to using a parts library such as NopSCADlib for this kind of thing, but from the looks of the GitHub repo, [Mihai] decided to implement his own versions of the screws, nuts, washers, and sections of metal extrusion used to construct the garden wall.

We recently covered the advantages of “building” a complex multi-part project like a CNC control cabinet virtually in your CAD tool of choice before bending metal on the real thing. This project is a fantastic example of that concept, as it shows that the technique isn’t limited to electronic components.

Archiving The World’s Oldest Webcam Feed

FogCam is the oldest webcam feed that’s still up and running. Installed at San Francisco State University, it’s been slowly uploading a new image to the web every 20 to 60 seconds or so since September 30, 1994. Very few of those images have ever been saved, but [Justin Earl] has come along to fix that with Fog-Bank.

[Justin] was eager to have top-notch coverage of the FogCam, so set up four separate catchers across three separate networks to scrape images from the feed. He runs one on his own server, one on his home machine, and two small programs running on Cloudflare. Each catcher reports the time it grabbed a fresh image from the site. FogCam has never replaced an image within 19 seconds, so as long as one of the catchers grabs an image at least every 18 seconds, [Justin]’s system should be archiving everything that’s being captured.

Currently the archive hosts over 169,000 images across 377 days, though the majority of that content is from a 2019 archive effort when it was believed the camera would soon be shut down. More stats are available, too.

It’s not the most interesting view in the world, but it’s neat to see such a project continue running long enough to celebrate its 32nd birthday this week. We’ve featured other neat webcam-related content before, too. Meanwhile, you can go check out the live feed if you want to peer through FogCam yourself. Continue reading “Archiving The World’s Oldest Webcam Feed” →

The Whole Computer Is Vim

Love it or hate it, Vim, the vi-compatible minimalist editor, is a common denominator between a huge array of operating systems. If you need to edit a file, it’s usually safe to expect it there if your normal editor is absent. Now thanks to [Omwah] it’s moved onto the most meager of platforms, where it becomes the firmware itself rather than a program running on an OS.

ESP-Vim is, as its name suggests, Vim, for some of the ESP32 series of microcontrollers. It boots straight into the familiar editor on an attached screen, and it has filesystem and git access, along with MicroPython. It’s a small computer for working with text files and some basic scripting, and we like the idea.

It needs a board with an ESP32-S3 or P4, with 16 MB of Flash and at least 8 MB of PSRAM. There’s a list of boards that meet this spec, and we can’t help noticing that one of them is the version of the Cheap Yellow Display that comes with an S3. Hook up a Bluetooth keyboard and you’re in.

How easy it will be to use remains to be seen, but bearing in mind that the vi interface followed by Vim was designed for very slow terminals in a much earlier decade, and it could be just right for these platforms. Would you use one?


Vim logo: The Vim project, VIM License.