3D Printed Mechanical Keyboard

Tired of buying boring keyboards with almost no customization available? We’ve seen lots of keyboard hacks before, but if you want to take it a step further — why not make it from scratch and have it 3D printed?

Reddit user [Wildpanic] has just finished his first attempt at a 3D printed keyboard and he’s even shared the files to make it over at Thingiverse. The frame is entirely 3D printed, but he’s chosen to use pre-manufactured key switches, which is probably for the best. They are the Cherry MX Green variety, which have these little clips in the side which make them super easy to install — especially on a 3D printed frame.

He’s wired them all using 20ga copper wire (which might be a bit overkill) to a Teensy 2.0 microcontroller. The diodes he chosen to use are 1N4148 which he was able to get fairly inexpensively. Total cost is just a bit over $50. Not bad!

Oh and in case you’re wondering, he’s chosen the style of keyboard that makes use of 4 keys for the space bar — as made popular by the planck style custom keyboards — you know, for people who love symmetry.

For more awesome keyboard hacks, check out this roundup [Adam Fabio] put together in a Hacklet last year!

[via reddit]

Using I2C Addresses as Chip Selects

I2C has a seven-bit address space, and you’re thinking “when do I ever need more than 127 devices on a pair of wires?” So you order up some parts only to find that they have one, two, or three user-configurable address pins for any given device type. And you need a bunch more than four or eight capacitive sensor buttons on your project. What do you do?

If you’re reader [Marv G], you think outside the box and realize that you can change the addresses on the fly by toggling address pins high and low with your microcontroller. That is, you can use a single I2C address pin for each device as a chip select signal just like you would have with SPI.

That’s it, really. [Marv G] goes through all of the other possible options in his writeup, and they’re all unsavory: multiple I2C busses, a multiplexer, buying different sensors, or changing micros. None of these are as straightforward as just running some more wires and toggling these with your micro.

We’d even go so far as to suggest that you could fan these chip select lines out with a shift register or one of those 1-of-N decoder chips, depending on how many I2C devices you need to chip-selectify. (We’re thinking 74HC595 or 74HC154.)

Along the way, we found this nice list of the number of address pins for a bunch of common peripherals provided by [LadyAda], in case you don’t believe us about how ubiquitous this problem is. How many devices on that list have one (1!!) address pin?

At the end of his post, [Marv G] asks if anyone else has thought of this chip select trick before. We hadn’t. Here’s your chance to play the smart-ass in the comments.

AVR Hardware Timer Tricked Into One-Shot

[Josh] has written up two posts that those of you who use AVRs might find handy. The first post documents a C library that implements a jitter-free one-shot timer. The second post explains how it works. We think it’s such a good idea that we’re going to spoil it for you, but go ahead and read his links and check out his code.

A one-shot is a pulse generator that runs once and only once. You trigger it, it produces the desired pulse, and that’s all she wrote. Why is this handy? Many external ICs that you’ll interface with have minimum durations for signal pulses that must be respected. You could program the AVR to toggle a pin high and then sit around and wait until it’s time to toggle the pin low again, but this wastes valuable CPU time, isn’t going to be very precise, and is susceptible to timing discrepancies if interrupt routines fire in the mean time.

You’d think that you could use the hardware timers for this, but it’s not straightforward. Normally, the timers are free-running; the counter that’s keeping track of time rolls over the top and starts over again. But we just want one pulse.

[Josh]’s very clever idea abuses the timer/counter’s TOP and MATCH values in “Fast PWM” mode. Essentially you trick the counter into never matching by setting TOP below MATCH. This means that the counter spins in its loop between zero and TOP forever, doing nothing.

To break it out of its loop and enable the one-shot, you manually set the counter to a value above TOP and let it go. As it counts up, it’ll eventually hit MATCH, turn on your pin, and then keep counting. When it rolls over the top (255 + 1 = 0 for the 8-bit AVRs), your pin will be correctly turned off again and then the counter re-enters its loop. The one-shot won’t fire until you manually set the counter higher than TOP again.

So there you have it, a one-shot depending only on the hardware timer/counter module and thus immune to jitter and consuming no CPU time at all. Our hats off to you, [Josh]. Clever hack.

A Hacker-Friendly Blinky USB Stick

The availability of Smart RGB LED’s, either as individual units, as strips or even as panels, have made blinky light projects with all kinds of color control and transition effects easy to implement using even the simplest of controllers. Libraries that allow control of these smart LEDs (or Smart Pixels as they are sometimes called)  make software development relatively easy.

[overflo] at the Metalab hackerspace in Vienna, Austria recently completed development of usblinky – a hacker friendly blinky USB stick. It can control up to 150 WS2812B smart LED’s when powered via an external power supply, or up to 20 LED’s when powered via a computer USB port. The micro-controller is an ATTiny85 running the Micronucleus bootloader which implements software USB using vUSB. The hardware is based on the DigiSpark platform. The usblinky software sources are available on their Github repo. The section on pitfalls and lessons learned makes for interesting reading.

Metalab plans to run workshops around this little device to get kids into programming, as it is easy enough and gives quick visual feedback to get you started. To round off the whole project, [overflo] used OpenSCAD to design a customizable, 3D printable “parametric orb” which can house the LED strip and make a nice enclosure or psychedelic night light. Check out the mesmerizing video of the usblinky Orb after the break.

Thanks to [papst] for sending in this tip.

Continue reading “A Hacker-Friendly Blinky USB Stick”

Custom PLCs for Automation Industries

For many years, factories have used PLCs for automated control over industrial equipment. These systems are usually expensive, proprietary, and generally incapable of being reprogrammed. [Oliver], an engineering student in Ireland created a system for factories to develop their own application-specific PLCs as a final project for Automation Engineering.

In-house PLC creation has many benefits for manufacturers, not the least of which is the opportunity for customization. Making your own PLCs also means no licensing fees and total control over equipment automation. This system is a complete setup including an HMI interface with touchscreen input and a SCADA system for remotely controlling various pieces equipment of equipment from a laptop.

[Oliver] built a metal frame out of industrial-grade strut channel to house an XP machine, two monitors, and the beautifully breadboarded PLC design station. It’s based around a PIC16F887 and includes rugged features expected of a system that never goes into sleep mode, like eight channels of opto-isolation. [Oliver] also developed an environment for engineers to easily program their custom PLCs through a simple HMI interface and ladder logic.

Calibrating The MSP430 Digitally Controlled Oscillator

The MSP430 is a popular microcontroller, and on board is a neat little clock source, a digitally controlled oscillator, or DCO. This oscillator can be used for everything from setting baud rates for a UART or for setting the clock for a VGA output.

While the DCO is precise – once you set it, it’ll keep ticking off at the correct rate – it’s not accurate. Without a bit of code, it’s difficult to set the DCO to the rate you want, and the code to set that rate will be different between different chips.

When [Mike] tried to set up a UART between an MSP430 and a Bluetooth module, he ran into a problem. Setting the MSP to the correct baud rate was difficult. Luckily, there’s a way around that.

There’s an easy way to set the DCO on the MSP programatically; just set two timers – one that interrupts every 512 cycles, with its clock source set to the DCO, and another that interrupts every 32768 cycles that gets its clock from a 32.768kHz crystal. The first timer clicks off every second, and by multiplying the first timer by 512, the real speed of the DCO can be deduced.

After playing around with this technique and testing the same code on two different chips, [Mike] found there can be a difference of almost 1MHz between the DCOs from chip to chip. That’s something that would have been helpful to know when he was playing around with VGA on the ‘430. Back then he just used a crystal.

Open Source Binary Wristwatch Is Professional Quality

If you want to proclaim to the world that you’re a geek, one good way to go about it is to wear a wristwatch that displays the time in binary. [Jordan] designs embedded systems, and he figured that by building this watch he could not only build up his geek cred but also learn a thing or two about working with PIC microcontrollers for low power applications. It seems he was able to accomplish both of these goals.

The wristwatch runs off of a PIC18F24J11 microcontroller. This chip seemed ideal because it included a built in real-time clock and calendar source. It also included enough pins to drive the LEDs without the need of a shift register. The icing on the cake was a deep sleep mode that would decrease the overall power consumption.

The watch contains three sets of LEDs to display the information. Two green LEDs get toggled back and forth to indicate to the user whether the time or date is being displayed. When the time is being displayed, the green LED toggles on or off each second. The top row of red LEDs displays either the current hour or month. The bottom row of blue LEDs displays the minutes or the day of the month. The PCB silk screen has labels that help the user identify what each LED is for.

The unit is controlled via two push buttons. The three primary modes are time, date, and seconds. “Seconds” mode changes the bottom row of LEDs so they update to show how many seconds have passed in the current minute. [Jordan] went so far as to include a sort of animation in between modes. Whenever the mode is changed, the LED values shift in from the left. Small things like that really take this project a step further than most.

The board includes a header to make it easy to reprogram the PIC. [Jordan] seized an opportunity to make extra use out of this header. By placing the header at the top of the board, and an extra header at the bottom, he was able to use a ribbon cable as the watch band. The cable is not used in normal operation, but it adds that extra bit of geekiness to an already geeky project.

[Jordan] got such a big response from the Internet community about this project that he started selling them online. The only problem is he sold out immediately. Luckily for us, he released all of the source code and schematics on GitHub so we can make our own.