Optical Tremolo

Time for another write up!
This time for the optical tremolo pedal that I built. What makes this tremolo pedal different from any other, you ask? The answer lies in it's name: Optical tremolo. Yes, that's right, this tremolo uses light to create the volume changing effect that is a tremolo. This is how it does that:
And LED light is positioned above a photo resistor, and a motor spins a disk with a pattern cut out of it . When the disk spins, light can shine through the patter cut out of it, thus hitting the photo resistor.
When light hits a photo resistor, it's resistance increases. So when you run a signal through the photo resistor while you have the LED lit and the motor with a pattern disk spinning, you get a pattern of varied resistance (and therefor volume) that corresponds to the pattern on the disk. Voilà! Tremolo.
I got the idea for this project from MAKE: Magazine Vol. 15, but you can read the article online for free here: MAKE: Optical Tremolo

Everything is powered off of a 9 volt battery.
The only controls on the tremolo pedal are a switch to reverse the motor (For A-symmetrical pattern disks), a 5-way switch speed control, an "amount" potentiometer (wired in series with the photo resistor), and an on/off switch. Watch a video demo on my Youtube channel!

Finally, here are some pictures:

(Pattern disks aren't pictured, because I seem to have lost them... Haha)

The Raspberry Pi Guitar Effect Box

Today I wanted to post an article about my Raspberry Pi based guitar effect box. Here we go:

 This project, as mentioned previous, is a guitar effect unit based on and powered by a Raspberry Pi "micro-computer" and the free DSP software "Pure Data". All of the effects are written in the Pure Data (Or "PD") language. The effect box currently contains 15 effects in all, but the entire system was built around the concept that the user should be able to switch out effects for new ones very easily. Continuing on, the effect unit (Or "pedal" as I'll refer to it from now on) consists of six main components: The buttons, the potentiometers, the VFD display, the ADC (Reads pots), the USB sound card, and the Raspberry Pi itself. I'll now go over what each component does. First, the buttons. There are three momentary push buttons on the front panel of the pedal. They enable you to cycle through effects and enter menu screens. The top most button acts as a "next" button, cycling through to the next effect, and the bottom most buttons acts as a "previous" button, cycling through to the previous effect. When the middle button is pressed, the pedal enters "edit mode", in which the user can edit the parameters of an effect, such as a chorus's speed or depth, by using the four potentiometers on the front of the pedal. This brings us into a description of how the potentiometers function. Each potentiometer is wired as a voltage divider into a channel of the ADC chip, which converts the voltage off the pot to a digital value, and that digital value takes the place of a hard coded value in a PD effect file, thus changing a certain parameter of an effect.  Moving on, when the pedal is in "normal" (non-edit-mode) the VFD display shows the name of the currently selected effect, and what it's editable parameters are. The parameters are listed from right to left, corresponding to their own potentiometer. Using the image below as an example, the user has selected the effect called "Chorus" using the next/previous buttons. You can see that the editable parameters for this effect are (from right to left): Speed, Depth, and Fdbk (Feedback). If the pedal were in edit mode, the parameter "Speed" would be controlled by potentiometer #1, the one closest to the orange cable; the other parameters following suit with potentiometers #2, and #3.
  

The front panel, showing the buttons, pots, and VFD

Now we have covered 4 of the six components. Next is the USB sound card.

Inside the pedal

The photo above shows the internals of the pedal. In the top center you can see the Raspberry Pi model B, the heart of the device. Connected to it via the GPIO pins is the main circuit board, which holds the ADC chip and various resistors. I'll provide a link to the schematic at the end of this post. Also connected to the Raspberry Pi is a small black rectangle with both a yellow and a black cable connected to it. This is the USB sound card. The yellow cable is the audio input from your guitar, and the black is processed audio out from Pure Data. The reason a USB sound card was necessary was because the Pi doesn't have a built in audio-in port. Having covered 5 of the 6 main components, all that remains is the Raspberry Pi. I'm not the person to explain the Pi, so I'll redirect you here to learn more about it.

Finally, to end this post, here are some more pictures:
  
The VFD display and four pots
A shot of the pedal with my amp and strat

The 'Tiger Eye' Robot Writeup - As seen on raspberrypi.org

Hi! My name’s Ben.
I’ve always had a big interest in robotics and electronics in general, so when I heard about the Raspberry Pi, I knew I had to build a robot around it. This is what I came up with:

The robot, ready to do your bidding. Necessary wifi dongle not shown.

The base of the robot is an old iRobot roomba 4000 with all of the cleaning brushes and their respective motors removed.
The model of roomba that I used has two drive wheels and a coaster wheel in front, and the drive wheels draw almost 300mA of current, so powering them directly off of the Raspberry Pi’s GPIO obviously wouldn’t work. So, I considered using a relay board  to control the two drive motors from the GPIO. However, it turns that all the good boards were a little too expensive for a hobby project, so I decided to open the roomba up and see if I could somehow control the motors from the existing circuitry. Guess what? It turns out that there are four small transistors on the main board that power four larger transistors that deliver power to the motors. This means that there are two transistors per motor: one for forwards and one for backwards.

The four small transistors I mentioned are circled in red. Behold my soldering!

They’re labeled Q13, Q14, Q30 and an un-labeled one near R129.
I had a little help in discovering this from a video that a man named Dean Segovis had posted on YouTube, but I ended up taking a multimeter to the board; just to make sure that I wasn’t hooking my precious pi up to anything dangerous. You can watch Dean’s video here: https://www.youtube.com/watch?v=TVp6QWcoilk.
Once I had confirmed the location of the transistors I needed on the board, I connected their bases to GPIO pins 4, 17, 18 and 21 on the Raspberry pi with with a 16 pin socket that I had lying around.
To power the Raspberry Pi, I soldered together a power supply circuit around a 1 amp  5 volt regulator (basically the regulator and two capacitors) on a piece of perf board and had the 5v output from the regulator run to a micro USB connector. I also added some miscellaneous components to the circuit, like a power switch, a 2.5 Amp fuse, a 12 volt in socket and some 12 volt out sockets; one of which the camera is plugged into. The roomba’s main board is also plugged into a 12 volt out socket.
For the camera, I just used an ip network camera from the company Vivotek.
I had tried to use a USB webcam that you might use for skype calls, but streaming video from the pi slowed it way down and the picture quality wasn’t as good as I had wanted. I wasn’t using the best webcam in the world, though.
To hold the Pi in place on the robot, I just glued some plastic pegs where I wanted it to go:
One in between the USB and Ethernet ports, one in between the audio jack and the component video port, one near the HDMI port
and one near the SD card slot. This makes it easy to remove the Pi from the robot when It isn’t in use, yet it holds it in place very well.

The ‘holder’, with Rpi inserted.

The entire robot is powered off of a small 12 volt lead acid battery that fits nicely into the slot where the roomba’s original battery went. I could have used the original battery, but the one that came with my roomba was extremely old and wouldn’t take a charge any more. .
Lastly, I wrote some software in python to take input from a Nintendo wii remote and transmit the input it got to the Pi over wifi, where it’s decoded by another piece of python software and the wheels are moved according to the position of the joysticks on the wii remote. You can get my code at the links below:
Server.py – This one runs on the Raspberry Pi:
Server.py
Client.py – This one runs on your “base station” computer, a laptop for example:
Client.py
You can watch a short video of me driving the robot around on my YouTube channel:
https://www.youtube.com/user/doitnowlabs
And I think that’s about it. If I was unclear about anything or if you want a more detailed description of my project, please email me at benhjake (at) gmail.com , or leave a comment below. Also, if you replicate my project, I’d love to see a picture or two. You could email those to the same address. Thanks, and Happy Hacking!