Linux Fu: Named Pipe Dreams

July 12, 2019 by Al Williams 30 Comments

If you use just about any modern command line, you probably understand the idea of pipes. Pipes are the ability to connect the output from one program to the input of another. For example, you can more easily review contents of a large directory on a Linux machine by connecting two simple commands using a pipe:

ls | less

This command runs ls and sends its output to the input of the less program. In Linux, both commands run at once and output from ls immediately appears as the input of less. From the user’s point of view it’s a single operation. In contrast, under regular old MSDOS, two steps would be necessary to run these commands:

ls > SOME_TEMP_FILE
less < SOME_TEMP_FILE

The big difference is that ls will run to completion, saving its output a file. Then the less command runs and reads the file. The result is the same, but the timing isn’t.

You may be wondering why I’m explaining such a simple concept. There’s another type of pipe that isn’t as often used: a named pipe. The normal pipes are attached to a pair of commands. However, a named pipe has a life of its own. Any number of processes can write to it and read from it. Learn the ways of named pipes will certainly up your Linux-Fu, so let’s jump in!

Continue reading “Linux Fu: Named Pipe Dreams” →

The Saga Of 32-Bit Linux: Why Going 64-Bit Raises Concerns Over Multilib

July 9, 2019 by Tom Nardi 137 Comments

The story of Linux so far, as short as it may be in the grand scheme of things, is one of constant forward momentum. There’s always another feature to implement, an optimization to make, and of course, another device to support. With developer’s eyes always on the horizon ahead of them, it should come as no surprise to find that support for older hardware or protocols occasionally falls to the wayside. When maintaining antiquated code monopolizes developer time, or even directly conflicts with new code, a difficult decision needs to be made.

Of course, some decisions are easier to make than others. Back in 2012 when Linus Torvalds officially ended kernel support for legacy 386 processors, he famously closed the commit message with “Good riddance.” Maintaining support for such old hardware had been complicating things behind the scenes for years while offering very little practical benefit, so removing all that legacy code was like taking a weight off the developer’s shoulders.

The rationale was the same a few years ago when distributions like Arch Linux decided to drop support for 32-bit hardware entirely. Maintainers had noticed the drop-off in downloads for the 32-bit versions of their distributions and decided it didn’t make sense to keep producing them. In an era where even budget smartphones are shipping with 64-bit processors, many Linux distributions have at this point decided 32-bit CPUs weren’t worth their time.

Given this trend, you’d think Ubuntu announcing last month that they’d no longer be providing 32-bit versions of packages in their repository would hardly be newsworthy. But as it turns out, the threat of ending 32-bit packages caused the sort of uproar that we don’t traditionally see in the Linux community. But why?

Continue reading “The Saga Of 32-Bit Linux: Why Going 64-Bit Raises Concerns Over Multilib” →

Windows 10 Goes To Shell

June 10, 2019 by Al Williams 51 Comments

Windows 10 — the operating system people love to hate or hate to love. Even if you’re a Linux die-hard, it is a fair bet that your workplace uses it and that you have friends and family members that need help forcing you to use Windows at least some times. If you prefer a command line — or even just find a place where you have to use the command line, you might find the classic Windows shell a bit anemic. Some of that’s the shell’s fault, but some of it is the Windows console which is — sort of — the terminal program that runs various Windows text-based programs. If you have the creator update channel on Windows 10, though, there have been some recent improvements to the console and the Linux system that will eventually trickle down to the mainstream users.

What’s New?

So what’s new? According to Microsoft, they’ve improved the call interface to make the following things work correctly (along with “many others”):

Core tools: apt, sed, grep, awk, top, tmux, ssh, scp, etc.
Shells: Bash, zsh, fish, etc.
Dev tools: vim, emacs, nano, git, gdb, etc.
Languages & platforms: Node.js & npm, Ruby & Gems, Java & Maven, Python & Pip, C/C++, C# &
.NET Core & Nuget, Go, Rust, Haskell, Elixir/Erlang, etc.
Systems & Services: sshd, Apache, lighttpd, nginx, MySQL, PostgreSQL

The changes to the console are mostly surrounding escape sequences, colors, and mouse support. The API changes included things like allowing certain non-administrative users to create symlinks. We’ve made X Windows work with Windows (using a third-party X server) and Microsoft acknowledges that it has been done. However, they still don’t support it officially.

Continue reading “Windows 10 Goes To Shell” →

Running Linux On A Thermostat

June 10, 2019 by Ted Yapo 8 Comments

When your thermostat comes with Linux running on it, that’s not a hack. When it doesn’t, and you get Linux on there yourself, it most definitely is. This is exactly what [cz7asm] has done. In a recent video, he shows the Honeywell thermostat booting Linux and running a wide range of software.

While the hardware inside the thermostat doesn’t afford all the luxuries of a typical modern embedded Linux, it’s got enough room for the basics. The system runs from a 1 MB rootfs in RAM, and has a 2.5 MB kernel image, leaving a spare 12 MB for everything else. With just these meager resources, [cz7asm] shows how the system can use a USB network adapter, connecting to telehack.com for some command-line retro fun, and host a web server, although no browser runs yet. There’s also framebuffer support for displaying graphics and animations, and the usual Linux terminal goodness.

All we’ve seen so far is the video, so we hope [cz7asm] posts the code somewhere, because we’re tired of using our thermostat just to run the AC.

You might remember [cz7asm] from his previous thermostatic triumph: running Doom. Check out the video of the latest thermostat adventure after the break.

Thanks to [Piecutter] for the tip!

Continue reading “Running Linux On A Thermostat” →

The Finest Linux Tablet You Can Build

June 6, 2019 by Brian Benchoff 45 Comments

For the last few years now, we’ve all had access to tiny, affordable Systems on a Module. These wunderchips are complete Linux systems with WiFi, a halfway decent GPU, and enough memory to run a real system. This is the perfect platform to base a tablet build on, the only problem is that someone has to actually do it. The DLT One is the ‘Damn Linux Tablet’ from [Prof. Fartsparkle]. It’s the answer to the question of when someone is going to build a tablet computer around one of these cheap Systems on a Chip that are floating around.

With many modules to choose from, the first task is actually choosing one of these Linux modules. [Fartsparkle] ended up with the Nvidia Jetson Nano, an impressive little board that has one distinct advantage: it’s drop-in compatable with the Raspberry Pi Compute Module, the Raspberry Pi-on-an-SODIMM. Given a single chassis, [Prof. Fartsparkle] can simply upgrade his tablet by getting a newer version of the Jetson Nano (or the Compute Module).

The current state of the board is basically an SODIMM socket on a board, with breakouts for Ethernet, a power jack, USB, and HDMI. That’s all there is to it, and design on the tablet chassis is ongoing.

Future updates for this tablet build will include USB-C PD, an mPCI-E connector that would allow for M.2 storage, LTE in some form or another and a dock that would allow you to turn this into a Surface-like laptop. It’s an amazing build, and one of the best entries we’ve seen in this year’s Hackaday Prize.

Turn Your Car Into A Simulator

May 14, 2019 by Bryan Cockfield 14 Comments

Video games, while entertaining to be sure, are a great way to experience things that could not easily be recreated in real life. Shooting aliens on a giant ring in space is an obvious example, but there are some more realistic examples that video games make much more accessible, such as driving a race car. You can make that experience as realistic as you want, too, and can even go as far as using a real car as your controller.

All modern cars use a communication system to allow their various modules to talk to one another. Fuel injection, throttle position, pedal positions, steering wheel angle, and climate control systems can all communicate on the CAN bus, and by tapping into that information the car can be used as a controller for a video game. Once you plug in to the OBD-II port on a car, you’ll need a piece of software to decode all of that information. [Andrew] uses uinput, a tool that allows Linux machines to take any input signal and map it in any way that can be programmed.

The build also includes the use of an integrated pico projector, allowing the car to be parked and turned into a simulator at any time. It’s similar to another project which used a Mazda instead of a Chevrolet Volt, but it just goes to show how straightforward it can be to take information from the CAN bus of a modern car.

Continue reading “Turn Your Car Into A Simulator” →

Building A Raspberry Pi Rover: My Big Fat Linux Weekend

May 9, 2019 by Lewin Day 46 Comments

Linux! Such a wonderful, rich, capable operating system has blessed us, and all for the low, low cost of absolutely free. It’s under the hood of countless servers, computers, phones, and embedded devices, and is the go-to solution for when you want to get the job done right. Why, then, does it curse me so?

Prologue

The penguin giveth, and the penguin taketh away.

My experience with the almighty penguin stretches back to the late 90s. Facebook hadn’t been invented yet, so most weekends were spent installing whatever came on the front of the latest computer mags. I wish I was kidding, but I’m really not.

Way back when, us kids would load the latest Red Hat or Fedora distribution onto our hand-me-down Pentium IIs, trying not to accidentally wipe our hard drive in the process. Limited to dial-up internet and very few help resources, it was pretty common that you’d spend hours watching progress bars tick over, only to wind up with no working mouse, or an X server that simply refused to start for man or God. Did I mention we did all this for fun?

Trying To Get Some Work Done

Of course, after growing up, real life and real responsibilities take over. Now, if I’m using Linux, it’s because I’ve got a job to do, not just because there’s nothing good to watch on Cartoon Network this weekend. I consider myself to be a fairly intermediate user. I’ve compiled a few things successfully, understood how to work with a variety of package managers, and once, just once, even managed to connect to a wireless network from the command line. There’s not a whole lot that phases me in this realm anymore.

For the past few years, I’ve been slowly working on a little rover by the name of TKIRV, powered by a Raspberry Pi. It was overdue for a camera upgrade, as I’d been using an old Microsoft webcam for far too long. I ordered a nice 1080p Raspberry Pi camera, and naturally the parts marinated in their boxes for a good couple of years. Finally, after much procrastination, I was eager to get my wheely boi back out on the road.

This was but the beginning my weekend slaying embedded Linux dragons.

Continue reading “Building A Raspberry Pi Rover: My Big Fat Linux Weekend” →