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” →

Raspberry Pi Streams Music Using Only The Default Linux Tools

May 2, 2019 by Bryan Cockfield 13 Comments

Getting a home music streaming system off the ground is typically a straightforward task. Using Apple devices with Airplay makes this task trivial, but if you’re a computing purist like [Connor] who runs a Linux machine and wants to keep it light on extra packages, the task gets complicated quickly. His goal is to bring audio streaming to all Linux platforms without the need to install a lot of extra software. This approach is friendly to light-footprint devices like the Raspberry Pi that he used in his proof of concept.

[Connor] created a set of scripts which allow streaming from any UNIX (or UNIX-like) machines, using only dependencies that a typical OS install would already have. His Raspberry Pi is the base station and streams to his laptop, but he notes that this will work between virtually any UNIX or Linux machine. The only limitation is what FFmpeg can or can’t play.

We definitely can appreciate a principled approach to software and its use, although it does seem that most people don’t have this issue at the forefront of their minds. This results in a lot of software that is bulky, making it difficult to maintain, use, or even know what it does, and also makes it harder for those of us that don’t want to use that type of software to find working solutions to other problems. It’s noble that [Connor] was able to create something without sacrificing any principles.

Automated Tuning Of Linux Audio

April 10, 2019 by Brian Benchoff 55 Comments

Audio systems in Linux are terrible. You’ve never known true pain until you’ve tried to set up a recording or broadcasting workstation running Linux. I did, twenty years ago, and nothing has changed since. This wasn’t really a problem when Linux was either used in server spaces or some nerd’s battle station, but now we have small single board computers that everyone uses and wants to turn into a modular synth. Welcome to paintown, because the Linux audio stack is terrible.

For the past ten years, [Dynobot] has been working on improving audio in Linux. This is a decade of reading manuals from IBM and Oracle, and a deep knowledge of how to adjust settings so audio actually works. All of this work is now combined into a single script that improves everything. This means the priority of the Audio group is changed, the thread priority is better, the latency is better, and for anyone who wants to set up a local streaming service, the network latency is better. It’s not everything, and there’s no mention of recording multitrack audio, but we’ll accept the baby steps here.

There are two relevant Github repositories for this, the first containing audio adjustments for Debian-based systems, including the Raspberry Pi. This should work on any single board computer running Debian, and has been tested on all the Raspberry Pis, the Allo Sparky, ASUS Tinkerboard, and the Odroid C2. There’s also a version for TinyCore-based Linux systems that improves the priority of the audio threads, changes the thread scheduling from ‘whatever’ to FIFO, and improves the latency. If you’re running Linux, and you’re doing something with audio, this is what you need.

Give Your Raspberry Pi SD Card A Break: Log To RAM

April 8, 2019 by Dan Maloney 82 Comments

The fragility of SD cards is the weak link in the Raspberry Pi ecosystem. Most of us seem to have at least one Pi tucked away somewhere, running a Magic Mirror, driving security cameras, or even taking care of a media library. But chances are, that Pi is writing lots and lots of log files. Logging is good — it helps when tracking down issues — but uncontrolled logging can lead to problems down the road with the Pi’s SD card.

[Erich Styger] has a neat way to avoid SD card logging issues on Raspberry Pi, he calls it a solution to reduce “thrashing” of the SD card. The problem is that flash memory segments wear out after a fairly low number of erase cycles, and the SD card’s wear-leveling algorithm will eventually cordon off enough of the card to cause file system issues. His “Log2Ram” is a simple Unix shell script that sets up a mount point for logging in RAM rather than on the SD card.

The idea is that any application or service sending log entries to /var/log will actually be writing them to virtual log files, which won’t rack up any activity on the SD card. Every hour, a cron job sweeps the virtual logs out to the SD card, greatly reducing its wear. There’s still a chance to lose logging data before it’s swept to disk, but if you have relatively stable system it’s a small price to pay for the long-term health of a Pi that’s out of sight and out of mind.

One thing we really like about [Erich]’s project is that it’s a great example of shell scripting and Linux admin concepts. If you need more information on such things, check out [Al Williams’] Linux-Fu series. It goes back quite a way, so settle in for some good binge reading.