Arduino MIDI sequencer displays a lot of data

This Arduino MIDI sequencer has no shortage of ways to display loop info. The screen above is a touch-sensitive interface that acts as the user input. But if this screen is not visible, you can still see which tracks have activated samples for each beat and what effects are being used. That’s thanks to the collection of display boards which are shown in the video after the break.

The setup acts as the MIDI front end, relying on other hardware to generate the samples. It presents all of the options through several pages on the 320×240 touch screen display. The Ardunio Mega is responsible for monitoring the UI data, crafting and sending the MIDI commands, as well as updating the LED-based display boards. These include bar graphs for the various effects, a four row by sixteen pixel beat pattern display, and 7-segment displays to track the current location within the loop. All in that’s 368 LEDs driven by 18 shift registers.

Update: Link to a gallery can be found after the break as well.

[Read more...]

AVR External Memory Interface (XMEM) reads input matrix

Reading from a large number of inputs, like this piano keyboard, can be tedious. Even when multiplexing there’s a lot to keep track of. But if you choose the right microcontroller, you may have hardware assistance. Here’s an ATmega640 is using it’s external memory interface to read the key matrix.

You may remember the Open Music Labs article about reading from a shift register using just one pin of a microcontroller. This time around a shift register is still used, but instead of pulling in a long line of parallel inputs, the switches are multiplexed to reduce the number of I/O pins used to read them.

A 74HC573 is used to facilitate the multiplexing. We won’t go into how that part is accomplished; there’s a separate post that explains the process. What’s unique here is that the XMEM peripheral of the AVR microcontroller is used to grab the data. This is intended for external memory chips, but if you get the timing just right, it greatly simplifies reading in a matrix of up to 128 inputs.

Reading inputs from shift registers using just one single pin

Here’s an interesting article about reading data from shift registers using less than three pins. 74HC165 shift registers are a popular choice for adding inputs to a microcontroller. They have a parallel input register which can be read using the latch, then shifted into a microcontroller via the data and clock pins. For those counting, that’s the three pins normally associated with driving these devices.

This hack first does away with the latch pin. The addition of a carefully trimmed RC circuit (capacitor is charged by the clock pin, then the resistor lets that cap slowly discharge) means that the device will not latch until after the clock stops toggling. This technique drops the control down to just two pins (data and clock). You can still use hardware SPI to read the data using this method. It’s the same as using SPI to drive 595 shift registers except the microcontroller reads data instead of writing it.

But wait, there’s more! The diagram above actually shows a way of reading this shift register with just one pin. Notice that the clock and data pins are now connected to just one of the microcontroller pins. The data pin has an added resistor, which keeps the current low enough that it will not compete with the clock signal coming from the microcontroller. In between clock pulses, the microcontroller switches from output to input to read the data pin on each cycle. Give it a try, it’s a fun experiment!

Controlling shift registers via SPI

Hack a Day’s very own (and very prolific contributor) [Mike Szczys] put up a great tutorial on how to drive shift registers with an SPI interface.

[Mike]‘s earlier tutorial of the 595 shift register goes through the functions of a shift register pin by pin. In a 595, bits for each position in the register are sent over one at a time. Most microprocessors have an Serial Peripheral Interface, and using an SPI bus means a lot less mucking about.

An ATmega168 was used for this build, although most Atmel chips can be made to work as an SPI master device. There are just three wires connecting the microcontroller to the shift register – SER, SRCLK, and RCLK. Like any other shift register setup, the build can be expanded by connecting the QH’ pin of the first 595 to the SER pin of the second.

[Mike] graciously made all the code for his build available. The video after the break is a 16-bit binary counter, a good stopping point before [Mike] rebuilds his Larson scanner/Cylon/Kitt, moving away from a PWM-based build to a register-based one.

[Read more...]

ATtiny hacks: Robot Halloween costume

When it comes to Halloween costumes, [Michael] doesn’t like buying expensive and poorly made bits of cloth and fabric that resembles [random Disney character]. Last year, his son decided to be a robot for Halloween and although gray spray paint and dryer vent hose make a very good costume, that only goes so far. The robot needed lights, so [Michael] spent a little time on this build that blinks a few LEDs in a random pattern.

The build is very simple; an ATtiny13 drives two 74HC595 shift registers. The code – all 30-odd lines of it – uses the random() function to shift high or low values to the shift registers. After pausing for a little bit, the cycle continues and a new patterns of LEDs light up.

The electronics of the robot costume could be easily transferred to another theme – astronauts need LEDs on their backpack, and of course aliens communicate with blinking lights. In any event, it would avoid last year’s fiasco with a dozen [Heath Ledger] Jokers. Check out the video of [Michael]‘s intergalactic robot son after the break.

[Read more...]

ATtiny hacks: 2313 driving a 4x4x4 LED cube

ATtiny Hacks Theme Banner

[Kirill] wrote in to share his ATtiny hack, a 4x4x LED cube. The 64 LED display is a great choice to fully utilize the hardware he chose. It’s multiplexed by level. Each of the four levels are wired with common cathodes, switched by a 2N3904 transistor. The anodes are driven by two 595 shift registers, providing a total of 16 addressable pins which matches the 4×4 grid perfectly. All said and done it only takes seven of the ATtiny2313’s pins to drive the display. This is one pin more than the chip’s smaller cousins like the ATtiny85 can provide. But, this chip does include a UART which means the project could potentially be modified to receive animation instructions from a computer or other device.

You may have noticed the USB port in the image above. This is serving as a source for regulated power in lieu of having its own voltage regulation hardware and is not used for data at all. Check out the animations that [Kirill] uses on the display by watching the video after the break. You’ll find a link to the source code there as well.

[Read more...]

Arcade controller in a box

[Alex] wanted to play video games with an arcade stick and buttons, but got sticker shock after seeing the price of commercially available controllers that connect to a computer via USB. He set out to build his own and ended up with the controller-in-a box that you see above.

At first he tried using an mbed microcontroller board but was unhappy with the latency built into the system that detected a button press, sent it via USB as a keyboard press, which was then interpreted as input by the game. He ditched the microcontroller completely and picked up a couple of 4021 parallel-to-serial shift registers. He had previously used this method to make his own SNES controller. The SNES uses two 8-bit shift registers to generate an 16-bit serial packet to send to the console. [Alex's] reused that system, adding an SNES controller plug to his arcade box, and using the SNES to USB converter he already had to connect to the computer. Now he’s got a portable controller for the cost of three buttons, the stick, and two IC’s.

He explains the project himself in the clip after the break.

[Read more...]

Follow

Get every new post delivered to your Inbox.

Join 92,089 other followers