CP/M Is Now Freer Than It Was

July 13, 2022 by Jenny List 32 Comments

It’s easy to think of the earlier history of desktop computing operating systems in terms of DOS, Windows, and Mac OS with maybe a bit of AmigaOS, TOS, or RiscOS thrown in. But the daddy of desktop computing, the OS that put word-processors and spreadsheets in 1970s offices and had a huge influence on what followed, isn’t among that list. Digital Research’s CP/M ran initially on Intel 8080-based machines before losing out to MS-DOS as IBM’s choice for their PC, and then gradually faded away over the 1980s. Its source has been available in some form with a few strings for a long time now, but now we have confirmation from Digital Research’s successor company that it’s now available without restrictions on where it can be distributed.

For years it was something an operating system that had been bypassed by the hardware and hacker communities, as the allure of GNU/Linux was stronger and most available CP/M capable machines were also 1980s 8-bit gaming platforms. But with the more recent increased popularity of dedicated retrocomputing platforms such as the RC2014 it’s become a more common sight in our community. Brush up your command line skills, and give it a go!

Header: Michael Specht, CC BY-SA 3.0.

Who Is Thinking About Open Source Firmware?

May 14, 2022 by Elliot Williams 23 Comments

Yesterday, we ran a post on NVIDIA’s announcement of open-source drivers for some of its most recent video cards. And Hackaday being huge proponents of open-source software and hardware, you’d think we’d be pouring the champagne. But it’s trickier than that.

Part of the reason that they are able to publish a completely new, open-source driver is that the secrets that they’d like to keep have moved into the firmware. So is the system as a whole more or less open? Yeah, maybe both.

With a more open interface between the hardware and the operating system, the jobs of people porting the drivers to different architectures are going to be easier. Bugs that are in what is now the driver layer should get found and fixed faster. All of the usual open-source arguments apply. But at the same time, the system as a whole isn’t all that much more transparent. The irony about the new NVIDIA drivers is that we’ve been pushing them to be more open for decades, and they’ve responded by pushing their secrets off into firmware.

Secrets that move from software to firmware are still secrets, and even those among us who are the most staunch proponents of open source have closed hardware and firmware paths in our computers. Take the Intel Management Engine, a small computer inside your computer that’s running all the time — even while the computer is “off”. You’d like to audit the code for that? Sorry. And it’s not like it hasn’t had its fair share of security relevant bugs.

And the rabbit hole goes deeper, of course. No modern X86 chips actually run the X86 machine language instructions — instead they have a microcode interpreter that reads the machine language and interprets it to what the chip really speaks. This is tremendously handy because it means that chip vendors can work around silicon bugs by simple pushing out a firmware update. But this also means that your CPU is running a secret firmware layer at core. This layer is of course not without bugs, some of which can have security relevant implications.

This goes double for your smartphone, which is chock-full of multiple processors that work more or less together to get the job done. So while Android users live in a more open environment than their iOS brethren, when you start to look down at the firmware layer, everything is the same. The top layer of the OS is open, but it’s swimming on top of an ocean of binary blobs.

How relevant any of this is to you might depend on what you intend to do with the device. If you’re into open source because you like to hack on software, having open drivers is a fantastic resource. If you’re looking toward openness for the security guarantees it offers, well, you’re out of luck because you still have to trust the firmware blindly. And if you’re into open source because the bugs tend to be found quicker, it’s a mix — while the top level drivers are made more inspectable, other parts of the code are pushed deeper into obscurity. Maybe it’s time to start paying attention to open source firmware?

Gridfinity: 3D Printed Super Quick Tool Storage And Retrieval

April 18, 2022 by Dave Rowntree 32 Comments

Our favourite cyborg [Zack Freedman] has been stumbling over a common problem many of us will be all too familiar with — that of tool storage and the optimal retrieval thereof. His solution is the Gridfinity: A modular workshop organisation system.

Never chase your pen around on the desk again

In [Zack]’s words, the perfect workshop has tools and materials arranged in the following way: (a) every item has a dedicated home within reach of where you’ll use it. (b) items are exposed and in position for instant grabification. (c) the storage system shields you from accidents like spills and injuries. (d) it is effortless to setup and easy to put back and rearrange. An instant-access storage solution such as the Gridfinity is designed not to help you store more stuff, but finish more projects. The idea is very simple — display your stuff so that you can quickly find what you need and get back to the project as quickly as possible. We think these aims are pretty spot on!

From an implementation perspective, the system consists of a 3D printed base plate with a grid structure. It is angled internally so storage bins drop in, but are not easy to knock out. Storage units drop into the grid in various sizes and orientations, such that everything is contained within the grid’s outer boundary, so the whole assembly will fit inside a drawer with ease. Small part storage bins have a curved inner surface enabling one to easily scoop out a part when required. A partial lid on the top allows them to be stacked vertically if required.

Super-quick access to fully sorted stock – no more searching

Whilst the system is work in progress, there are still about a hundred different storage units, for anything from 3D printer nozzles to racks for tweezers. Implemented as parameterised models in Fusion360, it is easy to tweak existing models for your stuff, or create totally new ones, from the supplied templates.

No discussion of tool organisation would be complete without first considering the king of tool organisation [Adam Savage], the principle of first order retrieval is a strong one. For a more in-your-face solution, you could go down the pegboard-on-wheels route, or perhaps if you’re less mobile and in a tight squeeze, then get comfortable with the French cleat and build something full custom right into the walls. Whatever solution you come up with, do share it with us!

Continue reading “Gridfinity: 3D Printed Super Quick Tool Storage And Retrieval” →

Easy, Extensible, Open

April 16, 2022 by Elliot Williams 16 Comments

I’m a huge DIY’er. I don’t like to buy things when I can build them myself. But honestly, that doesn’t always end up in the optimal allocation of my time, when viewed from a getting-stuff-done perspective. Sometimes, if you’ve got a bigger project in mind, the right way is the quick way, and the quick way is buying something that already works. But when that something is itself not hackable, you’d better be darn sure that it does what you need, and what you could reasonably expect to need in the future, out of the box. And that’s where extensibility comes in.

It’s rare to find products out there that are designed to be both easy to use for the newbie, but extensible for the advanced user. For one, it’s hard work to tick either one of these boxes alone, so it’s twice as hard to nail both. But my other sinking suspicion is that designers tend to have an end user in mind, and maybe only one end user, and that’s the problem. When designing for the newbie, convenience is king. Or if targeting the pro, you maximize flexibility, but perhaps at the expense of designed-in complexity.

There’s a way out, a cheat code, if you will. And that’s making the project open source. Go ahead and hide the complexity from the new user if you want — as long as the pro is able to dive into the schematics or the source code, she’ll figure out how to extend it herself. Openness frees the designers up to worry about making it easy to use, without compromising its flexibility.

I think that this blend of easy and extensible, through openness, is what fundamentally drove the success of Arduino. On the surface layer, there are libraries that just do what you want and drop-down menus with examples to access them. But when you needed to actually use the chip’s hardware peripherals directly, there was nothing stopping you. For the community at large, the fact that all of the code was openly available meant that extending the base was easy — and let’s not beat around the bush, the community’s libraries, tutorials, and example projects are the real reason for the success of the platform.

Look around you, and look out when you’re making that next non-DIY shortcut purchase. Is it easy to use? Can you make it do the things that it doesn’t yet do? Just two simple requirements, yet they seem to knock out so many products if you want both. Then look at those that are both simple and flexible — are they also open? At least in my little world, the answer is almost always “yes”.

M5Paper Gets Open Source Weather Display Firmware

November 12, 2021 by Tom Nardi 25 Comments

We know you like soldering irons, we’re quite fond of them ourselves. But the reality is, modular components and highly capable development boards allow the modern hardware hacker to get things done with far less solder smoke then ever before. In fact, sometimes all you need to finish your project is the right code.

Case in point, check out the slick electronic paper weather display that [Danko Bertović] shows off in the latest Volos Projects video. While it certainly fits the description of a DIY project, he didn’t have to put any of the hardware together himself. The M5Paper is an ESP32 development kit designed around a crisp 4.7″, 960 x 540 e-paper panel that includes everything from environmental sensors to an internal 1150 mAh battery. To make your handheld e-paper dreams come true, the only thing you need to provide is the software.

The weather display code provided by [Danko] should certainly get you going in the right direction. Now don’t get us wrong, there’s certainly no shame in just flashing his code to the device and plunking it on your desk. It’s a gorgeous looking interface, and we all know that a sprinkling of open source code is often all it takes to make a standard consumer device extraordinary. But by using the code he’s provided as a launching point, you can take this turn-key device and really make it your own.

Continue reading “M5Paper Gets Open Source Weather Display Firmware” →

Tracking Maximum Power Point For Solar Efficiency

September 19, 2021 by Bryan Cockfield 45 Comments

In days of yore when solar panels weren’t dirt cheap, many people (and even large energy companies) used solar trackers to ensure their panels were always physically pointed at the sun to make sure they harvested every watt of energy possible. Since the price of panels has plummeted, though, it’s not economical to install complex machines to track the sun anymore. But all solar farms still track something else, called the Maximum Power Point (MPP), which ensures that even stationary panels are optimized for power production.

While small MPP trackers (MPPT) are available in solar charge controllers in the $200 range that are quite capable for small off-grid setups, [ASCAS] aka [TechBuilder] decided to roll out an open source version with a much lower price tag since most of the costs of these units are in R&D rather than in the actual components themselves. To that end, the methods that he uses for his MPPT are essentially the same as any commercial unit, known as synchronous buck conversion. This uses a specially configured switch-mode power supply (SMPS) in order to match the power output of the panels to the best power point for any given set of conditions extremely rapidly. It even works on many different battery configurations and chemistries, all configurable in software.

This build is incredibly extensive and goes deep into electrical theory and design choices. One design choice of note is the use of an ESP32 over an Arduino due to the higher resolution available when doing analog to digital conversion. There’s even a lengthy lecture on inductor core designs, and of course everything on this project is open source. We have also seen the ESP32 put to work with MPPT before, although in a slightly less refined but still intriguing way.

Thanks to [Sofia] for the tip!

Continue reading “Tracking Maximum Power Point For Solar Efficiency” →

Pick Up The Ball And Run With It

September 11, 2021 by Mike Szczys 2 Comments

Once in a while we get to glimpse how people build on each other’s work in unexpected and interesting ways. So it is with the GateBoy project, a gate-level emulator built from die shots of the original Game Boy processor. The thing is, [Austin Appleby] didn’t have to start by decapping and taking photos of the chip. He didn’t even have to make his own schematics by reverse engineering those structures. Someone else had already done that and made it available for others to use. A couple of years back, [Furrtek] started manually tracing out the DMG chip and posted schematics to the DMG-CPU-Inside repo, kindly licensing it as CC-BY-SA 4.0 to let people know how they can use the info.

But playing Game Boy games isn’t actually the end game of [Austin’s] meticulous gate-level recreation. He’s using it to build “a set of programming tools that can bridge between the C/C++ universe used by software and the Verilog/VHDL universe used by hardware.” A new tool has been born, not for gaming, but for converting a meta language that assigns four-letter codes to gate structures (somewhat reminiscent of DNA sequences) and will eventually convert them to your choice of C++ or a Hardware Description Language for use with FPGAs.

The open source community is playing four-dimensional football. Each project moves the ball downfield, but some of them add an additional goal in an alternate hardware universe — advancing the aims of both (like finding and fixing some errors in [Furrtek’s] original schematics).

Of course the real challenge is getting the word out that these projects exist and can be useful for something you’re working on. For instance, [Neumi’s] depth sounding rowboat allows an individual to make detailed depth maps of lakes, rivers, and the like. It was in the comments that the OpenSeaMap project was brought up — a site working to create crowd sourced waterway charts. It’s the perfect place for [Neumi] to get inspiration, and help move that ball toward a set of goals.

How do we get the word out so more of these connections happen? We’ll do our part here at Hackaday. But it’s the well-document and thoughtfully-licensed projects that set the up playing field in the first place.