Driving An LCD Character Display Using Custom HID Codes

October 23, 2012 by Mike Szczys 19 Comments

Here’s an external display meant to help you keep track of your computer’s status. It connects via USB and is driven by a PIC microcontroller. It listens for a small set of commands, using those to implement a simple control protocol to drive the screen.

[Andrew Gehringer] designed the device around a PIC 18F2550, which offers native USB control. He’s using Microchip’s USB stack to enumerate the module as an HID device. It listens for commands 0x10 through 0x23. These clear the display, write strings to each of the four lines of the display, and switch the LCD backlight. Of course the project includes a program [Andrew] wrote to feed the display. It has a GUI which let’s him decide what information is displayed and how it is formatted. This helper app hangs out in the system tray for easy access.

Reading An N64 Controller With A Microcontroller

October 16, 2012 by Brian Benchoff 29 Comments

We’ve seen NES, SNES, Sega, and just about every weird controller Atari put out connected to microcontrollers, but connecting the N64 controller to a project has remained one of those seldom-seen, rarely copied endeavors, not often tackled by makers around the globe. [Pieter-Jan] decided to throw his hat in the ring and give reading an N64 controller with a PIC a try, and we’re pleased to report he’s been completely successful.

One of the difficulties of reading an N64 controller is simply the speeds involved; with only three pins on the controller port, the N64 controller uses a serial protocol to send 32 bits of controller data at a fairly fast rate. Armed with a PIC18F ‘micro, [Pieter] realized that programming in C would be too slow, he needed to go all the way down to the bare metal and program his micro in assembly.

Every time the N64 controller data needs to be read, the console sends out a 9-bit polling request. The controller responds in turn with a 32-bit sequence informing the console of the status of all the buttons and joysticks. Once [Pieter] got his micro sending the correct polling response, it was only an issue of parsing the data returned from the controller.

Right now, [Pieter] has a small demo board rigged up that flashes a LED whenever the A, B, or Z buttons are pressed. This can be expanded to the remaining buttons and joystick, but for now we’ll just enjoy [Pieter]’s demo after the break.

Continue reading “Reading An N64 Controller With A Microcontroller” →

7400 Project Encrypts And Decrypts Data

October 15, 2012 by Mike Szczys 8 Comments

[Nakul], [Nikilesh], and [Nischal] just finished posting about their entry in the 2012 Open 7400 Logic competition. It’s an encryption system based entirely on 7400 logic chips. The device operates on 8-bit binary numbers, which limits its real-world applications. But we bet they learned a lot during the development process.

The encryption algorithm is based on a the concept of cellular automaton. This is a something with which we’re already familiar having seen many Conway’s Game of Life projects around here. What we’re not familiar with is this particular wing of the concept called ‘Rule 30‘. It works well with this project because a complex pattern can be generated from simple beginnings.

After conceptualizing how the system might work the team spent some time transferring the implementation to the chips they had available. The end result is a quartet of chip-packed breadboards and a rat’s nets of wires, but the system is capable of both encrypting and decrypting data.

TouchIt Fabulously With Other People On The Internet

October 13, 2012 by Brian Benchoff 15 Comments

[John] from MIT is working on a project to bring a little bit of interactivity to the hacks he does. Because his hacks receive much more attention on the Internet than in real life, [John] made it so clicking a button in your browser can change something in the real world. He calls his creation TouchIt Fabulously (check out that URL!), and it allows a queue of people on the Internet to take part in a real-world hack.

The basic idea of [John]’s build is very simple: a microcontroller connected to the Internet and a 7-segment display receives button presses from random people on the web. [John] did a lot of work to make sure everything is ‘fair’ when a lot of people are hitting his server by including per-IP queuing and rate limiting.

Right now, it’s just a 7-segment display connected to the Internet with a live video stream. With each press of a button, the counter decrements by one, and the person to take it all the way to zero gets to put their comment up on the web site.

If this build receives a lot of interest, [John] plans on turning it into a much bigger build that will control the lights in his office, shoot ping-pong balls at him, and an interactive display where people can draw graffiti in one of MIT’s many hallways.

Now that [John]’s build is up on Hackaday, we look forward to the stress testing our readers will graciously provide.

Thanks go to [Steve Baconmeister] for sending this in and having the best fake name ever.

Configurable RFID Tag From 7400 Logic Chips

October 12, 2012 by Mike Szczys 16 Comments

This soldering nightmare is a configurable RFID tag which has been built from 7400-series logic chips. The beast of a project results in an iPhone-sized module which can be used as your new access card for security systems that uses the 125 kHz tags. The best part is that a series of switches makes the tag hand programmable, albeit in binary.

Of course this is an entry in this year’s 7400 Logic Competition. It’s from last year’s winner, and he’s spent a lot of time documenting the project; which we love. We were surprised that this many chips can be powered simply by what is induced in the coil from the reader. This is just one of the reasons the 7400-series have been so popular over the years. After working out the numbers, a 64-bit shift register was built to feed the tag ID to the encoding portion of the design. There were many kinks to work out along the way, but once it was functional a surface-mount design was put together resulting in the final product shown off in the video after the break.

Continue reading “Configurable RFID Tag From 7400 Logic Chips” →

Bootloader Brings USB, Firmware Updating To The ATtiny85

October 9, 2012 by Brian Benchoff 14 Comments

[Jenna] sent in a very cool bootloader she thought people might like. It’s called Micronucleus and it turns the lowly ATtiny 85 into a chip with a USB interface capable of being upgraded via a ‘viral’ uploader program. Micronucleus weighs in at just over 2 kB, making it one of the smallest USB-compatible bootloaders currently available.

The USB support comes from V-USB, a project that puts a virtual USB port on a suite of AVR microcontrollers. With V-USB, it’s easy to turn a Tiny85 into a keyboard, custom joystick, data logger, or computer-attached LED display.

One very interesting feature of Micronucleus is the ‘viral updater’ feature. This feature takes a new piece of firmware, and writes it to a Tiny85, disabling the current bootloader. If you’re designing a project that should have a means of updating the firmware via USB instead of the usual AVR programmer, this might be the bootloader for you.

Not bad for a bootloader that emphasizes small code size. At just over 2 kB, it’s possible to use this bootloader on the similar, smaller, and somewhat cheaper ATtiny45.

PIC Programming Adapter For The Raspberry Pi

October 8, 2012 by Mike Szczys 11 Comments

Here’s another offering when it comes to PIC programming from the Raspberry Pi. The design seeks to adapt the GPIO header so that it may be used for programming PIC microcontrollers, but this does involve a bit more than just physically connecting pins to the target chip. Most of the PIC family require a 12V programming level, and this setup makes that possible.

The sets of NPN transistors shown in the schematic fragment above are arranged in darlington pairs. They’re actually switching voltage from the 6V linear regulator built into the system using the Pi’s 3.3V pins. There’s also a 12V regulator, so you’re going to need a power supply that is capable of sourcing more than that.

We’ve seen a similar concept before but this design carries it a step further. There are several status LEDs built into the programmer, and it includes support for detecting which chip is being programmed. So far this covers just four different chips, but we’re sure that it could be adapted to fit your own needs.

[via Reddit]