It seems like all the cool kids are leaving the 8-bit hobby microcontrollers in the parts bin and playing with more advanced parts like Complex Programmable Logic Devices. [Chris] is no exception to the trend, and set out to generate his own VGA signal using one of the beefy semiconductors.

It seems that he’s using the acronyms CPDL and FPGA interchangeable in his post but according to the parts list this setup uses an Altera EPM7128SLC84-7N CPLD. In order to generate the VGA signal he needed a way to convert the digital signals from the chip into the analog values called for in the video standard. He chose to build a Digital Analog Converter for the RGB color values using a resistor network which he calculated using PSpice. The other piece in the puzzle is a 25.175 MHz oscillator to clock the CPLD. As you can see after the break, his wire-wrapped prototype works exactly as designed. The example code generates the rainbow bars seen above, or a bouncing box demo reminiscent of a DVD player screen saver.

Want to know more about programming CPLDs? We did a tutorial on the subject a while back.

Have you ever built a Digital to Analog Converter before? This is a circuit that can take the 0 or 5V coming off of several digital logic pins, combine them together, and spit out one analog voltage that represents that value. If you’ve never made one, here’s your chance. [Collin Cunningham] over at Make put together another lab video about DACs which we’ve embedded after the break.

The circuit above uses an R-2R resistor network – often called a resistor ladder – which you can learn much more about from the reference page that [Collin] links to. Although a DAC in an IC package is by far the most commonly found application, we do see these R-2R networks in audio hacks from time to time.

Electronic musical instruments are a lot of fun for a hacker because, with a small palette of tools, know-how and curiosity, they are easily modified. As with any hack, there is always the chance that the subject will be ruined, so it’s not necessarily worth the risk to muck about inside your thousand-dollar pro synthesizer. Luckily for all of us, there are shovel-fulls of old electronic musical toys littering the curbs and second-hand shops of the world. These fun little devices provide ample opportunity to get familiar with audio electronics and circuit bending techniques.

A note on definitions: the term “circuit bending” can be synonymous with “hardware hacking” in the world of audio electronics, and we have seen some debate as to which term is better suited to a given project. We welcome you to share your viewpoints in the comments.

Keep reading to get started.

Materials

So, you’ve heard of circuit bending and you want to give it a try eh? Well for this introduction, you’re going to need at minimum the following materials:

• electronic musical instrument (the bendee) with batteries or AC adapter
• alligator clips (for temporary connections)
• various resistors and/or a potentiometer
• ears

and it’s a great help if you also have:

• oscilloscope
• bench-top power supply
• camera

For our first attempt at circuit bending, we will be using a Yamaha PSS-14 keyboard. We found it by the side of the road, abandoned and lonely and without a friend in the world. Like mad scientists conducting mad genetic experiments on lonely abandoned animals, we will rebuild this poor creature to be better, stronger, and stranger than before!

Background Research

Thanks to our high-fallootin’ academic standards, we’ll start by researching a little bit about the keyboard in question. The more adventurous among you can skip this step and dive straight into the fun part. From Yamaha’s site, we can see that this model sports “100 Advanced Wave Memory Voices”–that’s their hilarious marketing term for “100 Pre-written Sound Files”–making this what’s known as a “Wavetable Synthesizer”. Wavetable synthesis is a very easy and cheap way to create sounds because you can simply copy a bunch of sounds to the memory of the chip and then read through them sample-by-sample, changing the sampling rate to change the pitch (or having separate samples for each pitch value, depending how much memory you have to play with).

Further research reveals that we’re not the first to circuit-bend this particular keyboard. This example and also this one show some interesting possibilities, and by the end of this article we’ll have a better idea of what they’ve done. But enough talk, let’s crack this baby open!

Here we see the PSS-14 in its original state: operational, but missing the case screws (it was held together by duct tape when we found it). Perhaps a previous owner did some exploration of their own?

The preprogrammed songs cover all the major categories of music: Memories, Cool&Hot, Favourites, Fun Time. When we were younger we used to listen to Cool&Hot music all the time, but then it got mainstream so now we’re mostly into the underground Memories scene. You haven’t lived ’till you’ve heard the new remix of “Gallant Pig”.

There are twenty keyboard-controlled voices to choose from, most of which sound about the same. The volume controls seen here make a very loud “bongo” sound when you press them, no matter if the volume’s as low as possible.

Look Under the Hood

Clearly this thing could be better, so let’s open it up and see what we can improve about its operation.

The circuit board under the hood is pretty sparse, which is somewhat unsurprising seeing as it’s a wavetable synth and therefore most of the fun stuff is taken care of inside the microcontroller seen on the right. If you can find old electronic musical toys from before the digital era, you have access to a lot more of the nitty-gritty sound generation. Unfortunately those are much harder to find on the side of the road.

On the left side of the circuit board we can see the clearly-marked Vcc and GND connections, which would be easy enough to find from the battery terminals. The keyboard takes 4 AA batteries, which means it runs on a 6-Volt supply. We didn’t have the AC adapter for this keyboard so we’ll run it off of our bench-top power supply for now.
This hardly needs to be said but BE REALLY CAREFUL if you are going to use an AC-powered device. The bench-top supply we’re using has a current-limiter but a wall-wart transformer can push dangerous  crowds of electrons through your body, which we understand to be an uncomfortable experience.

On the right, we can see a bunch more resistors and–the holy grail–a clock component (it’s the blue blob to the left of the IC)! On digital synthesizers this is generally the main source of fun.

In the middle of the board there is a cluster of capacitors and what looks like a multi-transistor package. When we turn the board around and start probing, we’ll figure out what this is all about.

The soldered and printed side of the circuit board is much more interesting to look at. The dark patches that you see are conductive ink–this is a really common and cheap sensor technology used in everything from the humble NES controller to high-end Roland electric pianos. It’s a form of what’s known as a force-sensing resistor (FSR) and it suffers from major nonlinearity, hysteresis and repeatability. On the other hand, it’s dead easy to implement and it can be printed onto a board.

On the underside of the CPU we can start to characterize the pin functions. A lot of the pins go out to the various keys and buttons. A lot of those transistors that we saw topside are dedicated to this key matrix, too.

Scope it Out

Upon further investigation the button/key states are time-division multiplexed onto pulse wave signals based on a global excitation, illustrated here. According to this fellow who lists a circuit-bent PSS-15 (same model as this but with a silver control panel), connecting part of the audio output to the keyboard matrix returns can re-trigger buttons or keys to make “loops”. Very interesting, seeing as:

The keyboard uses a PWM-based DAC scoped here in comparison to the audio output further down the line. Again this is a very cheap technology (you can make one for your arduino pretty easily) and you can get a simple explanation here. Right off the bat we can see that a disadvantage to this technology is that its transition times between various voltage levels might be difficult to control, possibly leading to distortion. That aside, it will be interesting to connect the PWM DAC output to one or more of the keyboard matrix returns.

Here is a closeup of two interesting “hack points” on this keyboard. We’ll change the resistors on the right to see what it does to the signal, and we’ll change up the existing 8MHz clock for a different one.

The sine wave oscillations of component CL1 can be scoped to show a transformation into square wave, which we can safely assume is driving the operations of the microcontroller.

Modifying the Circuit

It just so happened that we had a spare 3MHz oscillator sitting around, so let’s find out what happens when we drive this device at 3/8ths of its normal speed.

A quick and dirty soldering job gives immediate results. In the video you can hear the results with the new clock and changing the resistor value at the PWM output–overdrive city!

Furthermore, by patching the audio output to parts of the keyboard matrix, we can create the “loops” as discussed eariler.
The results thus far have been, well, a little underwhelming. We can make the sounds slower and we can make little loops, and we’ve learned a little bit about consumer-level electronic toys. Still, at this point we were hoping to have unlocked some seriously badass digital fury.
Serendipity came to our help at this point, and an inadvertent touch of the oscillator legs produced the righteous vibes we’d been banking on!

The sounds that came out of this thing were incredible. Somehow, after assembly, this type of thing was happening at startup and it’s now only about a one in ten chance that the keyboard boots properly. Even then it’s at running 3/8ths speed… except some of the time, somehow, it properly adapts the PWM output so that despite the underclocked CPU the wavetables read at the original sampling rate. Who knows what is going on that ASIC.

What to do with it now?

At this point in our circuit-bending adventure we’ve characterized the operation of the device and found a couple of fun bends. Where to go from here? Well, one option would be to make the modifications permanent with the addition of pots, buttons, patchbays and what-have-you so that the end result is a sleek and performable instrument. We’ll be saving for a later date. Since, as we mentioned at the beginning of the article, it is quite possible to destroy a hacked piece of electronics simply by virtue of the stress caused by the modifications themselves, we’re going to finish this bend by recording the myriad new sounds that the keyboard produces, and composing a short celebratory piece of music:

Summary

While you may not have this exact toy keyboard at your disposal, the same techniques and methodology used here can be applied to many other audio devices. It’s simply a matter of

1. Taking your time
2. Understanding the technology
3. Characterizing the circuit
4. Experimenting

At the end of the day it’s not really that difficult to get started at this sort of thing–hopefully the concept of circuit bending has been demystified for some of you. This isn’t to say that circuit bending can’t go deeper than shown here, as this only shows the most elementary steps. And the complexity of the device you’re working with greatly affects the types of bends you can do–for example, the TR909 has many timing circuits that can be played with in much the same way as our Yamaha. We’ve recommended it and we’ll recommend it again, but for further reading be sure to check out Nick Collins’ Handmade Electronic Instruments. It contains a good section on toy hacking, and it’s generally a very good read.

If you enjoyed this introduction and want us to write further articles exploring different parts of circuit bending (or audio hacking in general), please let us know in the comments.

Serial communications are a mainstay of digital computing. They don’t require much physical infrastructure and they exist in variations to fit almost any application. The behaviour of serial communications lines, varying from high to low voltage in a timed pattern, is analogous to a 1-bit DAC. Using a whole DAC for serial communication would be a waste in most cases, but the [RobotsEverywhere] team found an exception which you may have encountered already.

Since the audio output of the Android is accessible and addressable, [RobotsEverywhere] wrote source code to use the left and right channels as separate serial communication lines. This circumvents the need to bust into the device and muck about with the hardware which is great if you want a no-risk hack that allows communications to an RS232 port. Any hardware on which you can write to the DAC (and control the sampling rate) is a potential target.

There are some external electronics required to convert the audio signal to TTL, but it’s not very complicated–a couple of comparators and change. You can see it in action after the break.

As a bonus, when you’re done for the day you can plug in your headphones and listen to the soothing poetry of pulse waves all night long.

This programmable power supply is the perfect addition to your bench tools. [Debraj Deb], who previously built a whole house power monitor, designed this build around a PIC 18F4520 microcontroller. The desired voltage is set with an attached keypad, resulting in a digital output on the 8-bits of port D. The port connects to another protoboard with an R-2R digital-to-analog converter resulting in the target voltage. A set of transistors amplifies the current and a power transistor then takes care of the final output. After the break you’ll find two videos, the first walks us through the hardware and the second demonstrates the device in action, along with measurements of its performance. This certainly provides a lot more functionality than an ATX power-supply conversion.

Update: A big thanks to [Debraj] who sent us a code package as well as the schematic (PDF) used during testing. We’re having trouble getting the code package up for download right now. Check back later, hopefully we’ll have it up soon.

Part 1

Part 2

Behold [Retromaster's] field programmable gate array implementation of an Atari 2600. The processor and video chip have both been built in the 100,000 gate Spartan-3E FPGA, with connectors for audio, video, and a Sega controller. The output signals are generated using two DACs made from R-2R resistor ladders, much like the project we saw in August. [Retromaster] included functionality for the system switches (difficulty and select) in the controller itself. There is VHDL code and board details available if you want to make one of your own. To help in making that decision we’ve embedded video of it after the break.

[Thanks Gokhan]

Want to take back control of how your digital audio files become sound? One thing you can do is to build your own digital to analog converter. This one is made from discrete components, centered around a resistive ladder. Yes, there are a couple of integrated circuits in there which are used for demultiplexing the incoming signal but the magic happens in that R-2R network. The project is an interesting read and makes a point of looking at the issues raised when trying to precision match resistors. Apparently it can be done with 0.1% components if you have a lot of them and a multimeter that can measure down to seven decimal places.

[Thanks Bigbob]

[Hasse] built a one-handed video game controller for his brother. He fit everything he needed into the body of an existing controller and came up with a very usable system. The controller will be right-hand only, so the left shoulder button was moved underneath the right side where your middle finger can get at it. This leaves the d-pad and the left analog stick to account for. By combining an ATtiny44A, an accelerometer, and a digital to analog converter the controller can sense motion. The microcontroller reads in the accelerometer data, gives user feedback via four added LEDs on the d-pad, and the DAC feeds the appropriate signals back into the controller as if you were using the stick. There is even a switch to select whether the motion data is mapped to the analog stick or to the d-pad. We’ve included a demo video after the break.

Find that you also need some one-armed typing assistance? Check out this half-qwerty keyboard hack.

[Thanks Wim and Jeroen via Tweakers]

[Jacob] is working on his final project for the Copenhagen Institute of Interaction Design.  Based around Arduino, the quality and quantity of his build notes make this a fascinating read and there are several examples to listen to.

The project features a brilliant idea for input:  He uses a 1/8″ TRS connector (mini-jack) whose tip is the input to the DAC of the Arduino. There are conductive pads in the shape of a keyboard that you touch the tip of the connector to in order to complete the circuit. Alternatively, the other two conductors on the connector deliver power and ground for easy interface with external controllers. He built an example controller that uses an LED and photoresistor to alter the signal returning to the Arduino. Put your hand in front of the light and the sound changes.

[via Arduino: blog]

Linear Technology’s LTC2631A-LZ8 is an 8bit digital to analog converter (DAC) with an I2C interface. This DAC can output 255 different voltages, spaced evenly between 0 and 2.5volts. We previously demonstrated the LTC2640 with a three-wire SPI interface, but this version is controlled with only two signal wires.

We used the Bus Pirate universal serial interface tool to work with the DAC, but the same basic principals apply to any custom implementation. The connections between the Bus pirate and the LTC2631A are outlined in the table. We powered the chip from the Bus Pirate’s 5volt supply, but it would also work fine at 3.3volts.

The I2C bus requires pull-up resistors on both bus wires. 5volts is supplied to the pull-up resistors by connecting a wire from the 5volt supply to the pull-up resistor input terminal. Close the jumpers on the clock and data lines to supply the external voltage to the pull-up resistors.

Now, setup the Bus Pirate for I2C mode and activate the on-board power supply.

HiZ>m<–select mode
1. HiZ
2. 1-WIRE
3. UART
4. I2C
…
9. PC AT KEYBOARD
MODE>4<–I2C mode
900 MODE SET
202 I2C READY
I2C>p<–setup power supply
W/w toggles 3.3volt supply?
1. NO
2. YES
MODE>1<–don’t use 3.3volts
W/w toggles 5volt supply?
1. NO
2. YES
MODE>2<–use 5volt supply
9xx SUPPLY CONFIGURED, USE W/w TO TOGGLE
9xx VOLTAGE MONITOR: 5V: 0.0 | 3.3V: 0.0 | VPULLUP: 0.0 |
I2C>W<–capital ‘W’ activates the supply
9xx 5VOLT SUPPLY ON
I2C>v<–check the voltage levels
9xx VOLTAGE MONITOR: 5V: 4.9 | 3.3V: 0.0 | VPULLUP: 5.0 |<–supply on
I2C>

After configuring the Bus Pirate, the voltage monitor shows that the 5volt supply is active (4.9volts). Additionally, the monitor shows that 5volts is connected to the pull-up resistor supply terminal (VPULLUP).

I2C>(0)<–list available macros
0.Macro menu
1.7bit address search
I2C>(1)<–search for I2C devices
xxx Searching 7bit I2C address space.
Found devices at:
0×40 0xE6<–got reply from these addresses
I2C>

The state of pin 1 and 8 determine the LTC2631A I2C address, according to the table on page 22 of the datasheet. Instead of looking up the address in the datasheet, we used the Bus Pirate’s I2C address search macro to scan the entire I2C address range. The DAC responds to the set address (0X40) and a global address (0xE6). The global address is useful for controlling multiple DACs simultaneously over the same I2C bus.

I2C>d [0x40 0b00110000 0xff 0] d
9xx VOLTAGE PROBE: 0.0VOLTS<–output is 0volts
210 I2C START CONDITION<–start transaction
220 I2C WRITE: 0×40 GOT ACK: YES<–DAC address
220 I2C WRITE: 0×30 GOT ACK: YES<–set DAC output command
220 I2C WRITE: 0xFF GOT ACK: YES<–set DAC to full (255)
220 I2C WRITE: 0×00 GOT ACK: YES<–don’t care, extra byte
240 I2C STOP CONDITION<–end transaction
9xx VOLTAGE PROBE: 2.5VOLTS<–output at full
I2C>

Now we’re ready to interface the DAC. An initial voltage measurement (d) shows that the DAC is currently outputting 0volts.

An I2C start condition ([) alerts connected I2C devices to listen for their address. The first byte is the address (0x40) that identifies the device we want to access. The next byte is the LTC2631A command to update the DAC output (0x30 or 0b00110000), followed by the output setting (0xff or 255, 100% output). The final byte doesn't matter for the 8bit DAC we're using, but carries additional data bits for higher resolution versions of the DAC. The transaction is completed by sending the I2C stop condition (]).

After updating the DAC to 100%, a voltage measurement (d) shows that the output is 2.5volts.

I2C>d [0x40 0x30 0 0] d
9xx VOLTAGE PROBE: 2.5VOLTS<–DAC at 100%
210 I2C START CONDITION
220 I2C WRITE: 0×40 GOT ACK: YES
220 I2C WRITE: 0×30 GOT ACK: YES
220 I2C WRITE: 0×00 GOT ACK: YES<–set DAC to 0
220 I2C WRITE: 0×00 GOT ACK: YES
240 I2C STOP CONDITION
9xx VOLTAGE PROBE: 0.0VOLTS<–DAC at 0%
I2C>

A similar command sequence sets the DAC output back to 0. A voltage measurement confirms that the DAC output is now 0volts.

For a complete list of DAC features and command codes, see the in-depth discussion of the LTC2640 SPI DAC at the end of the Bus Pirate version 1 how-to.

Are there any chips you’d like us to interface in future parts posts?

Bug Labs makes hardware modules that can be combined to create your own custom gadgets. They’ve just released what we consider the most useful module: BUGvonHippel. Unlike the previous single purpose modules, the BUGvoHippel is a universal interface. The bus features USB, power/ground, DAC/ADC, I2C, GPIO, SPI, serial, and more. BUG applications are written in Java using a custom IDE.

The $79 module is named after MIT professor Eric von Hippel, who wrote Democratizing Innovation. You can find an interview with him below.

[via Engadget]