Posts with «the hackaday prize» label

A Macro Keyboard In A Micro Package

Remember back in the early-to-mid 2000s when pretty much every cheap USB keyboard you could find started including an abundance of media keys in its layout? Nowadays, especially if you have a customized or reduced-sized mechanical keyboard, those are nowhere to be seen. Whenever our modern selves need those extra keys, we have to turn to external peripherals, and [Gary’s] Knobo is one that looks like it could’ve come straight out of a fancy retail package.

The Knobo is a small macro keypad with 8 mechanical Cherry-style keys and a clickable rotary encoder knob as its main feature. Each key and knob gesture can be customized to any macro, and with five gestures possible with the knob, that gives you a total of thirteen inputs. On top of that, the build and presentation look so sleek and clean we’d swear this was a product straight off of Teenage Engineering’s money-printing machine.

The actions you can do with those inputs range from simple media controls with a volume knob all the way to shortcuts to make a Photoshop artist’s life easier. Right now you can only reprogram the Knobo’s Arduino-based firmware with an In-Circuit Serial Programmer to change what the inputs do, but [Gary] is currently working on configuration software so that users without any programming knowledge will be able to customize it too.

Knobs are just one of those things that everyone wants to use to control their computers, much like giant red buttons. Alternative input devices can range from accessibility-designed to just downright playful. Whatever the inspiration is for them, it’s always nice to see the creativity of these projects.

The HackadayPrize2019 is Sponsored by:

Probability-Based Drummer Leaves The Beats Up To Chance

Drum machines may seem like one of the many rites of passage for hardware makers, they’re a concept you can implement simply or take into the extreme making it as complex as you want. [Matt’s] DrumKid is one of them, and its long development history is wonderfully documented in the project logs.

[Matt’s] original intention was to use the automatic drummer as part of his band, wanting “the expressiveness of a good drummer but without the robotic tendencies of a simple drum machine”. For that, he created the first iteration of the DrumKid, a web-based project using the Web Audio API. The interface consisted of bars showing levels for different settings which could be intuitively tweaked, changing the probability of a drum sound being played. This gave the “drummer” its unpredictability, setting itself apart from any regular old drum machine.

Fast forward a few years, and [Matt] now wants to recreate his DrumKid as a proper piece of musical gear, porting the concept into a standalone hardware drum machine you can plug into your mixer. He decided to go with the Arduino framework for his project rather than the Teensy platform in order to make it cheaper to build. The controls are simplified down to a few buttons and potentiometers, and the whole thing runs off of three AAA batteries. Also, targeting the project for hardware like this allowed for new features to be added, such as a bit-crush filter.

We already saw the first prototype here on Hackaday when it was featured in a Hackaday Prize mentor session, and it’s nice to see how the project evolved since. After a number of revisions, the new prototype takes design cues from Teenage Engineering’s “Pocket Operator” drum machine, using the main PCB as its own faceplate rather than a 3D printed case in a familiar way we’ve seen before. Unfortunately, the latest board is non-functional due to a routing mistake, but you can see the previous working prototypes in his project logs.

The HackadayPrize2019 is Sponsored by:

A Multi-Layered Spin On Persistence Of Vision

By taking advantage of persistence in human vision, we can use modest bits of hardware to create an illusion of a far larger display. We’ve featured many POV projects here, but they are almost always an exploration in two dimensions. [Jamal-Ra-Davis] extends that into the third dimension with his Volumetric POV Display.

Having already built a 6x6x6 LED cube, [Jamal] wanted to make it bigger, but was not a fan of the amount of work it would take to grow the size of a three-dimensional array. To sidestep the exponential increase in effort required, he switched to using persistence of vision by spinning the slight source and thereby multiplying its effect.

The current version has six arms stacked vertically, each of which presents eight individually addressable APA102 LEDs. When spinning, those 48 LEDs create a 3D display with an effective resolution of 60x8x6.

We saw an earlier iteration of this project a little over a year ago at Bay Area Maker Faire 2018. (A demo video from that evening can be found below.) It was set aside for a while but has now returned to active development as an entry to Hackaday Prize 2019. [Jamal-Ra-Davis] would like to evolve his prototype into something that can be sold as a kit, and all information has been made public so others can build upon this work.

We’ve seen two-dimensional spinning POV LED display in a toy top, and we’ve also seen some POV projects taking steps into the third dimension. We like where this trend is going.

The HackadayPrize2019 is Sponsored by:

Insert Coin (Cell) To Play LedCade

In this era of 4K UHD game console graphics and controllers packed full of buttons, triggers, and joysticks, it’s good to occasionally take a step back from the leading edge. Take a breath and remind ourselves that we don’t always need all those pixels and buttons to have some fun. The LedCade is a μ (micro) arcade game cabinet built by [bobricius] for just this kind of minimalist gaming.

Using just three buttons for input and an 8×8 LED matrix for output, the LedCade can nevertheless play ten different games representing classic genres of retro arcade gaming. And in a brilliant implementation of classic hardware hacking humor, a player starts their game by inserting not a monetary coin but a CR2032 coin cell battery.

Behind the screen is a piezo speaker for appropriately vintage game sounds, and an ATmega328 with Arduino code orchestrating the fun. [bobricius] is well practiced at integrating all of these components as a result of developing an earlier project, the single board game console. This time around, the printed circuit board goes beyond being the backbone, the PCB sheet is broken apart and reformed as the enclosure. With classic arcade cabinet proportions, at a far smaller scale.

If single player minimalist gaming isn’t your thing, check out this head-to-head gaming action on 8×8 LED arrays. Or if you prefer your minimalist gaming hardware to be paper-thin, put all the parts on a flexible circuit as the Arduflexboy does.

The HackadayPrize2019 is Sponsored by:

SENSEation Shows The Importance of Good Physical Design

Sensor network projects often focus primarily on electronic design elements, such as architecture and wireless transmission methods for sensors and gateways. Equally important, however, are physical and practical design elements such as installation, usability, and maintainability. The SENSEation project by [Mario Frei] is a sensor network intended for use indoors in a variety of buildings, and it showcases the deep importance of physical design elements in order to create hardware that is easy to install, easy to maintain, and effective. The project logs have an excellent overview of past versions and an analysis of what worked well, and where they fell short.

One example is the power supply for the sensor nodes. Past designs used wall adapters to provide constant and reliable power, but there are practical considerations around doing so. Not only do power adapters mean each sensor requires some amount of cable management, but one never really knows what one will find when installing a node somewhere in a building; a power outlet may not be nearby, or it may not have any unoccupied sockets. [Mario] found that installations could take up to 45 minutes per node as a result of these issues. The solution was to move to battery power for the sensor nodes. With careful power management, a node can operate for almost a year before needing a recharge, and removing any cable management or power adapter meant that installation time dropped to an average of only seven minutes.

That’s just one example of the practical issues discovered in the deployment of a sensor network in a real-world situation, and the positive impact of some thoughtful design changes in response. The GitHub repository for SENSEation has all the details needed to reproduce the modular design, so check it out.

An Unmanned Ground Vehicle, Compatable With An Arduino

Building your own robot is something everyone should do, and [Ahmed] has already built a few robots designed to be driven around indoors. An indoor robot is easy, though: you have flat surfaces to roll around on, and the worst-case scenario you have a staircase to worry about. An outdoor robot is something else entirely, which makes this project so spectacular. It’s the M1 Rover, an unmanned ground vehicle, built around the Arduino platform.

The design goal of the M1 Rover isn’t just to be a remote-controlled car that can be driven around indoors. This robot is meant for rough terrain, and is a robot that can be programmed, can also be driven around by a computer, a video game controller, or custom joysticks.

To this end, the M1 rover is designed around high-quality laser cut plywood, powered by a few DC motors controlled through a dual H-bridge, and loaded up with sensors, including a front-mounted ultrasonic sensor. All the electronics are tucked away in the chassis, and the software is just fantastic. In fact, with the addition of a smartphone skillfully mounted to the top of the chassis, this little robot can became an autonomous rover, complete with a webcam. It’s one of the better robotic rover projects we’ve seen, and amazing addition to this year’s Hackaday Prize.

DIY Puff-Suck Interface Aims for Faster Text Input

Puff and Suck (or Sip and Puff) systems allow people with little to no arm mobility to more easily interact with computers by using a straw-like unit as an input device. [Ana] tells us that the usual way these devices are used to input text involves a screen-based keyboard; a cursor is moved to a letter using some method (joystick, mouse emulator, buttons, or eye tracking) and that letter is selected with a sip or puff into a tube.

[Ana] saw such systems as effective and intuitive to use, but also limited in speed because there’s only so fast that one can select letters one at a time. That led to trying a new method; one that requires a bit more work on the user’s part, but the reward is faster text entry. The Puff-Suck Interface for Fast Text Input turns a hollow plastic disk and a rubber diaphragm into bipolar pressure switch, able to detect three states: suck, puff, and idle. The unit works by having an IR emitter and receiver pair on each side of a diaphragm (one half of which is shown in the image above). When air is blown into or sucked out of the unit, the diaphragm moves and physically blocks one or the other emitter-receiver pair. The resulting signals are interpreted by an attached Arduino.

How does this enable faster text input? By throwing out the usual “screen keyboard” interface and using Morse code, with puffs as dots and sucks as dashes. The project then acts as a kind of Morse code keyboard. It does require skill on the user’s part, but the reward is much faster text entry. The idea got selected as a finalist in the Human-Computer Interface Challenge portion of the 2018 Hackaday Prize!

Morse code may seem like a strange throwback to some, but not only does the bipolar nature of [Ana]’s puff-suck switch closely resemble that of Morse code input paddles, it’s also easy to learn. Morse code is far from dead; we have pages of projects and news showing its involvement in everything from whimsical projects to solving serious communication needs.

Energy Harvesting Design Doesn’t Need Sleep

Every scrap of power is precious when it comes to power harvesting, and working with such designs usually means getting cozy with a microcontroller’s low-power tricks and sleep modes. But in the case of the Ultra Low Power Energy Harvester design by [bobricius], the attached microcontroller doesn’t need to worry about managing power at all — as long as it can finish its job fast enough.

The idea is to use solar energy to fill a capacitor, then turn on the microcontroller and let it run normally until the power runs out. As a result, a microcontroller may only have a runtime in the range of dozens of microseconds, but that’s just fine if it’s enough time to, for example, read a sensor and transmit a packet. In early tests, [bobricius] was able to reliably transmit a 16-bit value wirelessly every 30 minutes using a small array of photodiodes as the power supply. That’s the other interesting thing; [bobricius] uses an array of BPW34 photodiodes to gather solar power. The datasheet describes them as silicon photodiodes, but they can be effectively used as tiny plastic-enclosed solar cells. They are readily available and can be arranged in a variety of configurations, while also being fairly durable.

Charging a capacitor then running a load for a short amount of time is one of the simplest ways to manage solar energy, and it requires no unusual components or fancy charge controllers. As long as the load doesn’t mind a short runtime, it can be an effective way to turn even indoor light into a figuratively free power source.

SPINES Design Makes for Modular Energy Harvesting

The SPINES (Self-Powered IoT Node for Environmental Sensing) Mote is a wireless IoT environmental sensor, but don’t let the neatly packed single PCB fool you into thinking it’s not hackable. [Macro Yau] specifically designed SPINES to be highly modular in order to make designing an energy harvesting sensor node an easier task. The way [Macro] sees it, there are two big hurdles to development: one is the energy harvesting itself, and the other is the software required to manage the use of every precious joule of that harvested energy.

[Macro] designed the single board SPINES Mote in a way that the energy harvesting portion can be used independently, and easily integrated into other designs. In addition, an Arduino library is being developed to make it easy for the power management to be done behind the scenes, allowing a developer to concentrate on the application itself. A solar-powered wireless sensor node is one thing, but helping people get their ideas up and running faster in the process is wonderful to see.

Roboshield Helps Your Robot Walk and Talk

The joy of building robots comes from being able to imbue them with as much or as little personality and functionality as you wish during the design and build process. While creative flair and originality is always a good thing, there’s a lot of basic needs many robots have in common with each other, so where possible it’s good to avoid reinventing the wheel so more time can be spent on more advanced features. Roboshield aims to help make the basics easy so you can let your robot freak flag fly!

At its core, it’s an Arduino shield that packs in a host of hardware to get your robot up and running. As far as motion is concerned, a PCA9685 module is used to allow the control of 8 servos, plus there’s a TB6621FNG dual motor speed controller that offers both speed control and forward/reverse. That’s enough to get your electronic buddy scooting about the floor and waving its arms in the air.

The party piece, however, is the Vstamp text-to-speech module. This device produces a beautiful cliche electronic voice, which your robot is legally required to use to recite Asimov’s Laws of Robotics. Overall, it’s a tidy project that can take the hassle out of getting your robot design up and running, leaving you to focus on the fun bits like death rays and tractor beams. We can’t wait to see it powering the next wave of sassy DIY robots.