Remote access is great, but if the machine stops booting, ceases to connect to the network, or needs low-level interaction like BIOS settings or boot management, remote access is worthless because it’s only available once the host computer is up and running. The usual solution is to drag a keyboard and monitor to the machine in question for physical access.
For most people, swapping cables in this way is an infrequent task at best. But for those who work more closely with managing hardware or developing software, the need to plug and unplug a keyboard and monitor into machines that otherwise run headless can get tiresome. The modern solution is KVM (keyboard, video, mouse) over IP, but commercial options are expensive. [Michael Lynch]’s TinyPilot on the other hand clocks in at roughly $100 of parts, including a Raspberry Pi and USB HDMI capture device. It does have to drop the ‘M’ from KVM (meaning it does not support a mouse yet) but the rest of it hits all the bases, and does it all from a web browser.
What exactly does TinyPilot do? It provides remote access via web browser, but the device is an independent piece of hardware that — from the host computer’s point of view — is no different from a physical keyboard and monitor. That means keyboard and video access works before the host machine even boots, so even changing something like BIOS settings is no problem.
[Michael] demonstrates his design in the video embedded below, but we encourage you to check out the project page for a fascinating exploration of all the challenges that were part of TinyPilot’s development.
The Arduino platform is one of the most versatile microcontroller boards available, coming in a wide variety of shapes and sizes perfect for everything from blinking a few LEDs to robotics to entire home automation systems. One of its more subtle features is the ability to use its serial libraries to handle keyboard and mouse duties. While this can be used for basic HID implementations, [Nathalis] takes it a step further by using a series of Arduinos as a KVM switch; although admittedly without the video and mouse functionality yet.
To start, an Arduino Uno accepts inputs from a keyboard which handles the incoming serial signals from the keyboard. From there, two Arduino Pro Micros are attached in parallel and receive signals from the Uno to send to their respective computers. The scroll lock key, which doesn’t do much of anything in modern times except upset Excel spreadsheeting, is the toggle switch between the two outputs. Everything is standard USB HID, so it should be compatible with pretty much everything out there. All of the source code and schematics are available in the project’s repository for anyone who wants to play along at home.
[Radishmouse], despite the handle, is not a mouse guy. Give him a keyboard and he will get around just fine in any OS or program. As it is, he’s got a handful of ThinkPads, each running a different OS. He wanted to be able to switch his nice mechanical keyboard between two laptops without the hassle of unplugging and replugging the thing. His solution: a DIY KVM foot switch.
He’s been learning about electronics and 3D design, and this problem was the perfect opportunity to dig in and get his hands dirty. After learning enough about the USB protocol and switches to figure out what had to happen, he made a prototype from a pâte tub. Though undeniably classy, this vessel would never survive the rigors of foot-stomping in feline territory. Fortunately, [radishmouse] has also been learning about 3D design. After some trial and error, he came up with a sturdy, curvy 3D-printed two-piece enclosure. We particularly like the blocks built into the bottom piece that shore up the USB ports.
An essential tool of many sysadmins is a portable terminal ready to plug into an ailing rack-mounted server to administer first aid. At their simplest, they are simply a monitor and keyboard on a trolley, but more often they will be a laptop pre-loaded with tools for the purpose. Sysadmins will hang on tenaciously to now-ancient laptops for this application because they possess a hardware serial port.
[Frank Adams] has taken a different route with his emergency server crash cart, because while he’s used an old laptop he hasn’t hung onto it for its original hardware. Instead, he’s used a Teensy and an LVDS driver board to replace the motherboards of two old Dell Latitude laptops, one of which is a simple KVM device and the other of which is a laptop in its own right featuring a Raspberry Pi 3. He’s produced a video as well, which we’ve placed below the break.
There was a time when laptop display panels were seen as unhackable, but the advent of cheap driver boards has meant that conversions such as this one have become a relatively well-worn path. The job he’s done here is a particularly well-executed one though, making good use of the generous amount of space to be found in an older business-class laptop. There isn’t a battery because this application doesn’t demand one, however, with the battery compartment intact it does not seem impossible that a suitable charger/monitor board could be included along with a boost converter to provide his 12V supply.
This isn’t the first Pi laptop in a re-used commercial machine’s case we’ve seen, there was also this Sony Vaio.
Sometimes you have a whole bunch of computers that you need to work with, and having a keyboard, monitor, and mouse for each one becomes too much to deal with. There are a multitude of solutions to this problem, but [Fmstrat] went the hacker route, and built their own.
The build is a rather unique way of controlling PCs remotely, but it does the job. A Raspberry Pi 3 is pressed into service as the core of the operation. It’s accessible over IP for remote control. Video is captured from the controlled machines through the combination of an HDMI-to-S-Video adapter and an analog video capture card plugged into the Pi. Keystrokes are sent in a roundabout way, first sent to a Pi Zero over a USB-to-Serial adapter. From there, the Pi acts as an emulated mouse and keyboard to the PC under control.
One caveat of remotely controlling computers over a network is that if things go pearshaped, it can become necessary to power cycle the machine. [Fmstrat] deals with this by fitting a relay board to the Pi 3, which is connected to the reset buttons of the machines under control.
It may not be the quickest, easiest, or industry standard way of controlling remote computers, but it works. [Fmstrat] tells us this build was primarily designed to get around the fact that there aren’t any decent cheap IP-KVM systems, and consumer motherboards don’t support the IPMI standard that would otherwise be useful here.
We particularly like the hard-wired relays for rebooting a machine – great for when a network dropout is stopping Wake-on-LAN packets from achieving their goal. While the conversion of HDMI outputs into analog video for capture is unusual and somewhat costly on a per-machine basis, it’s functional and gives the system the ability to work with any machine capable of outputting a basic analog video signal. With the Pi Zero keyboard emulation and analog video capture, we could see this being used with everything from modern computers to vintage 80s hardware. If you’ve ever needed to control an Amiga 2000 remotely for whatever reason, this could be the way to do it.
Back in the old days, when handing someone a DB serial cable when they asked for a DE serial cable would get you killed, KVM switchers were a thing. These devices were simple boxes with a few VGA ports, a few PS/2 ports, and a button or dial that allowed your input (keyboard and mouse) and output (video) to be used with multiple computers. Early KVMs were really just a big ‘ol rotary switch with far, far too many poles. Do you remember that PS/2 wasn’t able to be hot plugged? The designers of these KVMs never knew that.
Today, KVM switchers are a bit more complicated than a simple rotary switch. We’re not dealing with VGA anymore — we have HDMI muxes. We’re also not dealing with PS/2 anymore, and USB requires a bit of microelectronics to switch from one computer to another. For one of his many Hackaday Prize entries, [KC Lee] is designing a low-cost HDMI switch and USB mux. It works, it’s cheap, and if you need to switch a keyboard, mouse, and monitor between boxes, it’s exactly what you need.
First off, the HDMI switching. Designing a switch for HDMI would usually take some obscure parts, intricate routing, and a lot of prototyping time. [KC] found a way around this: just hack up a $5 HDMI switch. This cheap HDMI switch is as simple as it gets, with an HDMI mux doing the heavy lifting and an 8-pin microcontroller to handle the buttons and a selector LED.
For the USB, there are a few more design choices. For USB 1.x switching, [KC] figures he can get away with a 74HC4052 dual 4:1 analog mux. Yes, he’s doing digital with analog chips, the heathen. There are drawbacks to this: everything could break, and it’s only USB 1.x, anyway. For a USB 2.0 KVM, there are a few more professional options. The OnSemi NCN9252 is a proper USB 2.0 mux, and in the current design.
When it comes to large systems, there are a lot more computers than there are people maintaining them. That’s not a big deal since you can simply use a KVM to connect one Keyboard/Video/Mouse terminal up to all of them, switching between each box simply and seamlessly. The side effect is that now the KVM has just as much access to all of those systems as the human who caresses the keyboard. [Yaniv Balmas] and [Lior Oppenheim] spent some time reverse engineering the firmware for one of these devices and demonstrated how shady firmware can pwn these systems, even when some of the systems themselves are air-gapped from the Internet. This was their first DEF CON talk and they did a great job of explaining what it took to hack these devices.