Posts | Comments

Planet Arduino

Archive for the ‘keyboard’ Category

If you have a serious visual impairment, using a computer isn’t easy. [Dhiraj] has a project that allows people fluent in Braille to use that language for input. In addition to having a set position for fingers, the device also reads the key pressed as you type. With some third party software it is possible to even create Word documents, according to [Dhiraj].

You can see the finished product in the video below. This is one of those projects where the idea is the hardest part. Reading six buttons and converting them into characters is fairly simple. Each Braille character uses a cell of six bumps and the buttons mimic those bumps (although laid out for your fingers).

Our thoughts are that it might be nice to have some tactile feedback on the first switch since the intended users probably can’t see the switches. Perhaps the audio sounds a little rough, but that could have been the speakers. Maybe also a dedicated spacebar and an easier way to select letters vs figures without moving your hands might be nice, too. None of that would be hard to fix.

The code was quite simple, though we can see that you might get some false keystrokes. Every 250 milliseconds the Arduino reads the seven input switches (the seventh switch is the letters/figures select). Then a giant if statement decodes the letter. Just stylistically, we would have probably built a number and used it to select from an array, as with 7 switches it would consume just 128 bytes. More importantly though we would probably wait for at least one on to off transition to start the decoding. The switches are active high, so we’d probably write something like this:

unsigned code,oldcode;
do {
   code=read_button_code();  // get current code
   } while (oldcode<=code);
// process oldcode

If this looks confusing, try a few examples (you can do that online, too). At first, the oldcode is zero so code will never be less than that (note the integers are unsigned). As long as bits keep getting set, code will be greater than or equal to oldcode. However, if any bit goes from 1 to zero then the total magnitude of code must be less than oldcode. That triggers the processing. Of course, you might also want to debounce the switches in read_button_code to make sure you have a stable input, too.

Still, what a great and useful idea it is, and one easy enough to build on the original design. We’ve seen a Braille tablet before. If you have some spare space on your next PCB, you could always replace some community signs.

The modern keyboard enthusiast is blessed with innumerable choices when it comes to typing hardware. There are keyboards designed specifically for gaming, fast typing, ergonomics, and all manner of other criteria. [iot4c] undertook their own build for no other reason than nostalgia – which sounds plenty fun to us.

An Arduino Leonardo is pressed into service for this hack. With its USB HID capabilities, it’s perfectly suited for custom keyboard builds. It’s built into a working Atari 65XE computer, and connected to the keyboard matrix. The Keypad and Keyboard libraries are pressed into service to turn keypresses on the 80s keyboard into easily digseted USB data.

There’s plenty of room inside the computer for the added hardware, with the USB cable neatly sneaked out the rear. [iot4c] notes that everything still works and the added hardware does not cause any problems, as long as it’s not used as a computer and a keyboard at the same time.

It’s possible to do a similar hack on the Commodore 64, too. If you’re doing tricky keyboard builds yourself, you know where to send ’em.

Even on the go, there is no substitute for a physical keyboard with buttons that move and click. Sure, you could solder a bunch of tactile switches to some perfboard, but how about going all out and making something robust as [Anthony DiGirolamo] did for his Teensy Thumboard. Everything is insertion-mount so it is an approachable project for anyone who knows the dangerous end of a soldering iron, and that also makes it easy to hack on.

Each pin of the Teensy has an adjacent empty hole tied to it for easy access, and the serial data pins are exposed at the top of the board. All the holes use standard 0.1″ (2.54mm) spacing. The I/O points used by the keyboard are labeled, and the rest of them can use the space under the controller where proto-board style holes add some extra space for an IMU or whatever sensors suit your slant.

Most impressive is the shell, which is freely available on Thingiverse, where you can also find a bill of materials with links to everything you will need in case you don’t have drawers full of those tactile switches.

If this looks familiar, you have probably seen the PocketCHIP, and it is no secret that this project is an homage to that versatile pocket computer. We appreciate this kind of love for PocketCHIP, especially since they are now a limited commodity.

Macros are useful things. They allow one to execute a series of commands with a single keypress. There exists a wide variety of hardware and software solutions to create and use macros to improve your workflow, and now [Evan] has brought the open-source ManyKey into the fray, along with a build tutorial to boot.

The tutorial acts as a great introduction to ManyKey, as [Evan] walks through the construction of a macro keyboard designed to be operated by the feet. Based around the Arduino Leonardo and using off-the-shelf footswitches commonly used in guitar effects, it’s accessible while still hinting at the flexibility of the system. Macros are programmed into the keyboard through a Python app which communicates over serial, and configurations are saved into the Arduino’s onboard EEPROM. The ManyKey source is naturally available over at GitHub.

[Evan] tells us he uses his setup to run DJ software with his feet while his hands are busy on the turntables. That said, there’s all manner of other applications this could be used for. Efficiency is everything, and we love to see keyboard projects that aim to improve workflow with new ideas and custom builds – this shortcut keyboard makes a great example.


The first time I saw 3D modeling and 3D printing used practically was at a hack day event. We printed simple plastic struts to hold a couple of spring-loaded wires apart. Nothing revolutionary as far as parts go but it was the moment I realized the value of a printer.

Since then, I have used OpenSCAD because that is what I saw the first time but the intuitiveness of other programs led me to develop the OpenVectorKB which allowed the ubiquitous vectors in OpenSCAD to be changed at will while keeping the parametric qualities of the program, and even leveraging them.

All three values in a vector, X, Y, and Z, are modified by twisting encoder knobs. The device acts as a keyboard to

  1. select the relevant value
  2. replace it with an updated value
  3. refresh the display
  4. move the cursor back to the starting point

There is no software to install and it runs off a Teensy-LC so reprogramming it for other programs is possible in any program where rotary encoders may be useful. Additional modes include a mouse, arrow keys, Audacity editing controls, and VLC time searching.

Here’s an article in favor of OpenSCAD and here’s one against it. This article does a good job of explaining OpenSCAD.

[Editor’s note: This is a Hackaday writer’s hack, hence the “I” in place of the usual “we”. We all love custom peripherals though, and a good number of us love OpenSCAD, so you could probably read it either way, but we don’t want to take credit for [Brian]’s work.]

Filed under: 3d Printer hacks, Arduino Hacks

For anyone who has owned a boombox or an old(er) cassette player, the digital age volume controls feel incredibly awkward. Keep pressing buttons to get the volume just right can get tiresome real quick. The volume knob just makes sense and in a simple project, [Jeremy S Cook] brings us the Custom Computer Volume Control Knob.

The build employs an Adafruit Trinket board coupled with a rotary encoder and a push button as described by the designers themselves. We reached out to [Jeremy S Cook] to enquire about the build and it turns out his version uses an MDF enclosure as well as an MDF knob. A larger PCB has the encoder and button solder on with the Trinket board connecting to them via multi strand wires. An Acrylic sheet cut to the size serves as the top cover and completes the build.

The button serves as a play/pause button and can come in handy. Since the device enumerates as an HMI device, it should work with almost any OS. It could easily be extended to work with Android Tablets or even iPads. Check out the video below for a demonstration and if you like the idea of custom input devices, check out this DIY shortcut Keyboard.

Filed under: Arduino Hacks

Create a custom 3D printed shortcut keyboard for design and other complex programs you work in.

Read more on MAKE

The post Making Your Own Custom Shortcut Keyboard appeared first on Make: DIY Projects and Ideas for Makers.

Working with CAD programs involves focusing on the task at hand and keyboard shortcuts can be very handy. Most software packages allow the user to customize these shortcuts but eventually, certain complex key combination can become a distraction.

[awende] over at Sparkfun has created a Cherry MX Keyboard which incorporates all of the Autodesk Eagle Shortcuts to a single 4×4 matrix. The project exploits the Arduino Pro Mini’s ability to mimic an HID device over USB thereby enabling the DIY keyboard. Pushbuttons connected to the GPIOs are read by the Arduino and corresponding shortcut key presses are sent to the host machine.

Additional functionality is implemented using two rotary encoders and the Teensy encoder library. The first knob functions as a volume control with the push-button working as a mute button. The encoder is used to control the grid spacing and the embedded button is used to switch between imperial and metric units. The entire code, as well as the schematic, is available on GitHub for your hacking pleasure. It’s a polished project just ready for you to adapt.

The project can be extended to be used with other computer software such as Gimp and the keys may be replaced by capacitive touch sensors making it more sturdy. Bluetooth can be added to make things wireless and you can check out the Double Action Keyboard to extend functionality further.

Filed under: Arduino Hacks, peripherals hacks

You’re not cool unless you have a mechanical keyboard. Case in point: if you were to somehow acquire an identical keyboard to the one I used to type this, it would set you back at least seven hundred dollars. Yes, it’s mechanical (Topre), and yes, I’m cooler than you. Of course, you can’t be as cool as me, but you can build your own mechanical keyboard. [Robin] is, I presume, a pretty cool dude so he built his own keyboard. It’s the amazing shortcut keyboard, and it can be programmed graphically.

The idea for this keyboard came when [Robin] was studying as an engineer. We assume this is code for wearing out the Escape key on AutoCAD, but many other software packages have the same problem. The solution to [Robin]’s problem was a shortcut keypad, a 3 by 4 matrix of Cherry switches that could be programmed for any task.

The design of this keyboard started out as an Adafruit Trellis matrix keypad. This was combined with some software written in Processing that assigned macros to each button. This was a sufficient solution, but the switches in the Adafruit trellis look squishy. These are not the right switches for someone who craves a soft snap under every fingertip. It’s not the keyboard of someone who desires the subtle thickness of laser etched PBT keycaps. The Adafruit keypad doesn’t have the graceful lines of a fully sculpted set of keycaps. Oh my god, it’s doubleshot.

[Robin]’s completed keyboard has gone through a few revisions, but in the end, he settled on PCB-mounted switches and a very clever 3D printed standoff system to hold an Arduino Pro Micro in place. The enclosure, too, is 3D printed, and the end result is a completely custom keyboard that’s perfect for mashing key combos.

You can check out a video of this keyboard in action below.

Filed under: Arduino Hacks, peripherals hacks

[DastardlyLabs] saw a video about converting a PS/2 keyboard to Bluetooth and realized he didn’t have any PS/2 keyboards anymore. So he pulled the same trick with a USB keyboard. Along the way, he made three videos explaining how it all works.

The project uses a stock DuinoFun USB mini host shield with a modification to allow it to work on 5V. An Arduino mini pro provides the brains. A FT-232 USB to serial board is used to program the Arduino. A standard Bluetooth module has to have HID firmware installed. [Dastardly] makes a homemade daughterboard–er, shield–to connect it to the Arduino.

The result is a nice little sandwich with a USB plug, a Bluetooth antenna, and some pins for reprogramming if necessary. Resist the urge to solder the Bluetooth board in–since it talks on the same port as the Arduino uses for programming, you’ll have to remove it before uploading new code.

If you need help reprogramming the HC-05 Bluetooth module, we’ve covered that before. This project drew inspiration from [Evan’s] similar project for PS/2 keyboards.

Filed under: Arduino Hacks

  • Newsletter

    Sign up for the PlanetArduino Newsletter, which delivers the most popular articles via e-mail to your inbox every week. Just fill in the information below and submit.

  • Like Us on Facebook