feurig's blog

98-all-your-atmel-belong-to-us

feurig — Wed, 14 Jul 2010 05:59:35 -0500

(Repost: http://blog.tempusdictum.com/index.php/don/system-admin/98-all-your-atmel-belong-to-us98-all-your-atmel-belong-to-us)

Foobarred is Normal

Recently I started using my linux laptop as my primary avr-usb development environment. When I upgraded the laptop to the current Ubuntu-LTS release (10.4 aka Lucid lynx) a bunch of stuff was broken including all of the wonderful udev rules provided by my linux savvy friends at dorkbotpdx.

I mean jeesh even lsusb was broken.

$ lsusb -vd "03eb:"|grep iM
cannot read device status, Operation not permitted (1)
iManufacturer           1

When I started looking at what changed and how to adjust, the web dead ended to a lot of threads like the one at http://ubuntuforums.org/showthread.php?t=1360412 ; where two people declared that having to escalate privileges to root in order to talk to a user device was "normal". Even when the developer said it wasn't normal the ubuntu folk redeclared it normal (apparently after Bush you just have to repeat something blatantly stupid for it to be true). As an administrator the last thing you want is everything and its dog requiring root privileges.

Hanging around the #ubuntu channel was a lot like having people repeat the searches on the web that provided me with the same dead ends that I joined the channel trying to resolve.

Cherchez la femme (look at the squeeze)

This was getting stupid. All I wanted to do was to have devices that I could plug in and program and then communicate with them using ruby or perl or some other haphazzardly thrown together scripts without having to be root. Then I realized once again that ubuntu is really focused on making the users life easier and that this leads to a lot of non technical help. So I asked my friends what the nick name was for the Debian release that was the basis for the Ubuntu release nick named "Lucid" and then re did all of my dead ended web queries replacing "Ubuntu Lucid" with "Debian Squeeze".

The results were heavy on the technical detail and light on social skills.

More importantly I quickly found the solution that I needed in the middle of this link (http://git.zerfleddert.de/cgi-bin/gitweb.cgi/usb-driver?a=blob_plain&f=R...) what I was missing and had been asking about was the difference between the new and the old udev rules.

"If you are running a newer version of udev (as in Debian Squeeze and
Ubuntu 9.10), you need to adapt the rules-file to the new udev-version:
sed -i -e 's/TEMPNODE/tempnode/' -e 's/SYSFS/ATTRS/g' -e 's/BUS/SUBSYSTEMS/' \
/etc/udev/rules.d/xusbdfwu.rules"

One line of sed was all I needed and it had taken me a week of asking about lucid when i should have been asking about squeeze. With this I also was able to find the changes to the lay out of the /dev and /proc trees and the new tools to monitor udev and diagnose issues.

All-Your-Atmel-Belong to Us

I really just wanted to change the permissions so I could use my devices. Adding the following udev rule to your system will do just that. You will also need to restart the udev service. Both of these will require you to be root.

# cat >/etc/udev/rules.d/98-all-your-atmel-belong-to-us.rules<<EOF
#------------------------/etc/udev/rules.d/98-all-your-atmel-belong-to-us.rules
#
# Make atmel devices (dfu, LUFA, obdev) accessible in userland
# 
ACTION=="add", SUBSYSTEMS=="usb", ATTRS{idVendor}=="03eb", MODE="0666"
EOF
# service udev restart

To actually own all my atmel I could have also added ' ,USER="don" ' after the mode part but I just wanted to talk my Atmel usb-avr devices and the open source firmware I was developing. And the above rule made things "just work".

$ lsusb -vd "03eb:"|grep iM
iManufacturer           1 mycompany.com
$

This rule fixed all of my LUFA based devices including the my open source arduino programmer as well as the dfu programmer.used to code them. Hopefully it will be a while before I have to go through this again.

Making Pigs Fly -- Object Space, Spokane 07-11 June 2010

feurig — Mon, 24 May 2010 19:54:29 -0500

http://www.osx-avr.org/electronics/making-pigs-fly/

Focused workshop: Artbots 30 May 10 -- PNCA ($35)

feurig — Mon, 24 May 2010 01:57:58 -0500

In this workshop we will be taking our dorkboards and using them to create a simple machine that draws. The focus will be on hands on problem solving.

What you will get.

A servo and a geared motor with paper feed.
A motor driver board.
Misc parts.

What to bring:

A dorkboard, teensy or other arduino capable board.
A soldering iron.
Some basic tools (esp wire cutters, x-acto knife)
superglue
A hot glue gun.
foamcore or cardboard.
$35 or a copy of your rsvp / paypal reciept.

Where:

PNCA -- 1432 NW Johnson St, Room 205

When:
Sunday May 30nd from 1 to 5pm

How do I rsvp?

Via paypal -- Select the session on the TDI Products page:
(http://tempusdictum.com/tdproducts.html)

You can also rsvp via email and bring cash but it is easier to plan and track the money if you use paypal.

Arduino Cult Induction -- 02 May 10 -- PNCA ($35)

feurig — Thu, 29 Apr 2010 01:33:33 -0500

http://www.dorkbotpdx.org/workshop/arduino/cult_induction_rev7

Running Paul Stoffregons's teensy_serial arduino core on DFU based chips.

feurig — Tue, 20 Apr 2010 16:47:18 -0500

With a lot of my projects I have done my prototyping with Paul Stoffregon's Teensy series of boards before moving them onto their own codebases. On those occasions where the "prototype was all I needed" I would compile the code using the teensyduino and then manually load the .hex file onto the target. As I am looking at using the arduino for more projects I decided to take a look at how paul interacts with the Arduino IDE and see if I could load code directly onto my chips.

boards.txt

The arduino allows for different chips and configurations through the boards.txt and the programmers.txt files. Each configuration usually will also have a "core" which maps the pins and handles the particulars of that chip. When you run paul's teensyduino installer it adds several entrys to the boards.txt file including the entry below.

teensy_ser.name=Teensy 1.0 (USB Serial)
teensy_ser.upload.protocol=halfkay
teensy_ser.upload.maximum_size=15872
teensy_ser.upload.speed=38400
teensy_ser.upload.disable_flushing=true
teensy_ser.upload.avrdude_wrapper=teensy_reboot
teensy_ser.build.mcu=at90usb162
teensy_ser.build.f_cpu=16000000L
teensy_ser.build.core=teensy_serial
...

Looking at pauls additions to the boards.txt I see that he is using the teensy_serial core that he has written to create a simple usb to serial interface and to map the usb avr pins and other peripherals to the arduino conventions. He is also adds an entry to the arduino uploader class which lets him use a wrapper for avrdude which lets him use his proprietary bootloader. This wrapper is installed by the Paul's installer and lives in the Arduino's bin directory. After looking to see if this wrapper was a script I replaced the entry in the boards.txt and put a script into the bin directory called "dfume", after seeing that my replacement wrapper worked I added two new entries for each class of avr that I wanted to use the atmega32u2 and the atmega32u4


#############################################################

fouryou.name = atMega32U4
fouryou.upload.protocol=atmega32u4
fouryou.upload.maximum_size=32256
fouryou.upload.speed=38400
fouryou.upload.disable_flushing=true
fouryou.upload.avrdude_wrapper=dfume
fouryou.build.mcu=atmega32u4
fouryou.build.f_cpu=16000000L
fouryou.build.core=teensy_serial

#############################################################

tooyou.name = atMega32u2
tooyou.upload.protocol=atmega32u2
tooyou.upload.maximum_size=32256
tooyou.upload.speed=38400
tooyou.upload.disable_flushing=true
tooyou.upload.avrdude_wrapper=dfume
tooyou.build.mcu=at90usb162
tooyou.build.f_cpu=16000000L
tooyou.build.core=teensy_serial

I started with a blank script that just printed the arguments passed to the wrapper and then called it by restarting my Arduino (to reload the boards.txt) And then selecting one of the new boards and "Uploading" my code. This gave me a window to interactively work through my script. Since the avrdude_wrapper code just pretends to be an avrdude most of the script is munging the arguments passed to avrdude to get the commands to pass to dfu-programmer.

#!/usr/bin/perl
use Getopt::Std;
print @ARGV;
my %args;
my $hexfile;
my $dfu = "/usr/local/bin/dfu-programmer";
my $cpu;
my $hexfile;

getopt('pUc',\%args);
$hexfile=$args{U};
$hexfile =~ s/flash:w://;
$hexfile =~ s/:i//;
$cpu=$args{c};

print "\n[" . $hexfile . "]";
print "\n[" . $cpu . "]\n";
print "$dfu $cpu erase\n";
system "$dfu $cpu erase";
print "$dfu $cpu flash $hexfile\n";
system"$dfu $cpu flash $hexfile";
print "$dfu $cpu start\n";
system "$dfu $cpu start 1>&2";
print "\n";

There is one tricky bit. The current avr-gcc doesnt support the atmega32u2 correctly but the code for the at90usb162 is binary compatible so the build.mcu is set to the at90usb162. But then dfu-programmer supports the correct chip and wont find the device so we use the fact that the upload.protocol argument is passed directlyalong using the -c argument and everything works fine.

So now we just use the hwb and reset buttons to get the system into dfu mode and upload our code directly from the arduino. Its not as slick as the teensy in "auto" mode but it works.

Reprogramming your avr-usb device using atmel's built in bootloader

feurig — Fri, 05 Mar 2010 15:48:36 -0600

Getting code onto the MidiMonster or Benito device.

Midi Monster Button Locations.	Benito 7g Switch Position
Benito 2010 Switch Locations	Benito Without Buttons

All of the code on the Benito and MidiMonster devices is open source and references an open source library called the Lightweight Usb For Avr (lufa). Getting the code compiled and onto the device requires a few other open source tools.

AVR-GCC

The most current and stable release of the toochain for the AVR has untill recently been maintained by Eric Wedddington and released as WinAvr (http://sourceforge.net/projects/winavr/) Winaver integrates nicely into atmels avr studio http://www.atmel.com/dyn/Products/tools_card.asp?tool_id=2725 and I reccomend that you get both if you are running windows. Each Winavr Release is closely followed on OSX by objective developments CrossPack for AVR http://www.obdev.at/products/crosspack/index.html and a script for building the current toolchain on linux which is hosted by AvrFreaks at present there is also a debian package that was put out last month http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=90172

HWB? DFU?

Most Atmel "atmega" devices have a pin dedicated to determining weather or not the device goes into the bootloader depending on the devices flag settings. This pin is labled HWB (for hardware boot) on most of the datasheets. The usb avr family has this mode set up by default. When you hold the hwb pin low and reset the device it goes into the bootloader. On these devices the built in bootloader uses a usb device class called the Device Firmware Uploader (DFU). Atmel provides a tool called flip for programming DFU devices on windows and linux. There is an open source programmer called dfu-programmer http://dfu-programmer.sourceforge.net/

That other guys stuff.

Those of you who have worked with the teensy boards from paul stoffregon will notice some subtle differences. Paul wrote his own (closed source) bootloader rather than use the bootloader tha comes installed on the chips. Then he uses a hardware trick similar to the auto reset hack to make a single button manipulate both the reset and the hwb pins to put his boards into the bootloader. I didnt feel that either the two button arrangement or the builtin bootloaders were broken so I like most people working with these chips dont fix them.

Using the dfu-programmer

All of the programs in Dean Cameras Lightweight Usb for Avr have a "dfu" target. Once you have the target into the DFU mode you can simply

$make dfu

This will cause the dfu-programmer to erase the flash reprogramm it with a new hex file and restart the chip. You can also do this manually with the following commands

$dfu-programmer atmega32u2 erase
$dfu-programmer atmega32u2 flash mycode.hex
$dfu-programmer atmega32u2 start

This will cause the dfu-programmer to erase the flash reprogramm it with a new hex file and restart the chip.

Focused Workshop: Programming the Midi Monster (28FEB10 PNCA).

feurig — Tue, 23 Feb 2010 16:23:13 -0600

What: Focused workshop: programming Midi devices using the Lightweight Usb For AVR library (Lufa) and the MidiMonster.

When: Sunday 28 Feb 2010 1-5 pm.

Where: PNCA (NW 12th and Johnson) #205

Cost: $35 (includes Midi Monster)
(If you have a MidiMonster from the PD Workshop and wish to use it please bring $10)

Materials: you Should Bring, a laptop and a mini usb cable. Please install Arduino >16 as well.

In this workshop we will be going through the firmware built by Alex Norman as an example of how to develop midi devices using the avr microcontoller. Topics covered will include:

The Midi Specification
The USB Midi Specification
The Lightweight Usb for AVR library.
Programming the avr using avr-gcc

To reserve a place in the class please rsvp at http://tempusdictum.com/tdproducts.html

Arduino Cult Induction , 31 Jan 2010, PNCA, $35

feurig — Thu, 21 Jan 2010 03:44:05 -0600

http://dorkbotpdx.org/workshop/arduino/cult_induction_rev7

Snails.

feurig — Tue, 15 Dec 2009 22:19:50 -0600

I have been thinking a lot about not having constant network connectivity. At least for the next week or so I am without it so I will have to work from experience. If you need something you can call me. There was also a time when things other than bills came in the mail.

420 SW College #B Portland, OR 97201

My sample design for the fabrication workshop.

feurig — Tue, 01 Dec 2009 17:42:42 -0600

At the eagle for fabrication workshop on sunday I started with a design that Thomas Lockney threatened to build about a year ago called the Low Fi Arduino Guitar Pedal.

(http://www.instructables.com/id/Lo_fi_Arduino_Guitar_Pedal/)

It was simple enough to get through the necessary parts of eagle that I was teaching and while it wasn't perfect It beat the hell out of Craig Anderton's circuits in terms of clarity and probability of actually working. To discuss from an over view perspective creating parts I decided to add the 1/4" jacks from another great dorkbotpdx project from Hans Lindauer.

Once I got the library part together for the 1/4" jack I had to rearrange things quite a bit but there was still pleanty of room. The next step was to add a power connector and a regulator. The idea is to be able to mount the resulting board in one of the cheapo danelectro pedels that I have around like this

In order to get the board to work out I had to create a new package for the potentiometers but I managed to get it all to fit on the board without resorting to surface mount components.

My example project is attached below (http://www.dorkbotpdx.org/files/ex sample.zip)

circuit design for fabrication

feurig — Thu, 12 Nov 2009 18:17:28 -0600

Workshop: circuit design for fabrication
(OpenTechSpace session 05DEC09 1-5pmTechShop $35)
Followup Session PNCA 06DEC09 1-5pm

As many of you may be aware Laen has been putting together a group ordering process for circuit board fabrications somewhat like SparkFun's BatchPCB service except with less time lag and the fabrication is done in the USA.

To introduce you to the tools needed to create circuit boards for this service (and most other circuit board services) we are presenting a workshop teaching you how to design a circuit board using Eagle PCB with an emphasis on getting designs that can be fabricated.

Workshop Time and Location

The workshop will be offered on two dates (Pick one):
* November 29th at PNCA (NW 12th and Johnson, room 205) (Google Calendar Link)
* December 5th through OpenTechSpace at Techshop (10100 SW Allen Blvd., Beaverton, OR 97005) (Google Calendar Link)

Follow-up Session:

A follow-up session will be offered on December 6th, 1pm-5pm at PNCA , to go over your designs, help with any problems, and getting them ready for submission for fabrication.

Fabrication included

Signing up for the class gets you three copies of your (up to 2 square inch) design in the December order. Designs submitted by the 10th of December will be included in this months PCB run and can be picked up at the meeting on the 21st (or mailed).

Topics covered.

Creating schematics
Organizing your files and libraries.
Laying out your parts effectively.
Routing your signals
Creating / finding parts that you need.
Documenting your board in the silkscreen
Using DRUs to design for a specific board fabricator
Using the ERC to check your designs for problems

What you will need

You should have some basic understanding of circuits but it is not critical You will need to bring a laptop which is capable of running eagle (linux,windows or mac -- see http://www.cadsoft.de/info.htm). The class is $35 and is limited to 30 so it is best to reserve a space in the class. Please rsvp at http://tempusdictum.com/tdproducts.html (eagle for fabrication)

Scary George. (driving a floppy drive stepper with the Arduino/Wiring platform)

feurig — Tue, 27 Oct 2009 19:08:33 -0500

I wanted to quickly demonstrate using a stepper motor from a floppy drive with the Arduino/Wiring platform as a follow up to the weekend's workshop. By the time we got to the stepper parts I was a bit scattered. So here is an example that I set up yesterday.

I have a talking George Bush doll from several years ago that was ripped in half (by people watching my punk band (w.busholini.org)) so I went ahead and finished dismantling it. For Halloween I thought his head should turn around Linda Blair style.

I wired up a ULN2803 Darlington array and a floppy drive stepper motor from the workshop as shown in the diagram above .

I figured out which wire was the common wire by taking an ohmmeter to the wires on the stepper. Most of the combinations were about 150 except from one of the wires on the end that read 75 ohms. Checking the 75 against all of the other wires I was able to determine that one of the wires was the common one and marked it with a sharpie.

Then I ran up the arduino (v 17) example program for the stepper library. I modified it so that it just made steps in one direction. When I ran it the motion was really jittery so I checked to make sure that my wiring was good and then rather than rewiring the stepper physically I changed the line in the code from

Stepper stepper(STEPS, 9, 10, 11, 12);

Stepper stepper(STEPS, 9, 11, 10,12);

And Whah La! his head started spinning just like he was possessed by Dick Cheney! I wired the talk button to pin 8 and then added some random delays which gave me the following.

#include <Stepper.h>

// change this to the number of steps on your motor
#define STEPS 100
int relayPin=8;
int ledPin=13;
// create an instance of the stepper class, specifying
// the number of steps of the motor and the pins it's
// attached to
Stepper stepper(STEPS, 9, 11, 10,12);

// the previous reading from the analog input
int previous = 0;

void setup()
{ pinMode(relayPin,OUTPUT);
  pinMode(ledPin,OUTPUT);
  // set the speed of the motor to 30 RPMs
  stepper.setSpeed(100);
}

void loop()
{
  // get the sensor value
  int val = analogRead(0);

  // move a number of steps equal to the change in the
  // sensor reading
  //stepper.step(val - previous);
digitalWrite(ledPin, HIGH);
stepper.step(random(5,90));
delay(random(60,2000));
digitalWrite(relayPin, HIGH);
delay(20);
digitalWrite(relayPin, LOW);
digitalWrite(ledPin, LOW);
stepper.step(-random(15,200));
delay(random(90,3000));
  // remember the previous value of the sensor
  previous = val;
}

Motors and Servos and Solenoids, OH MY (rev2).

feurig — Mon, 19 Oct 2009 05:23:27 -0500

On Sunday the 25th I am going to do an animtronicx workshop covering driving
motors, servos and relays with the arduino/wiring platform.
I will be covering the a couple of popular chips: The l293D for
driving motors , and the ULN2803 darlington array for driving relays,
stepper motors and other devices.
The workshop will cost $35 and will include these chips, a motor, a standard sized servo and a board for the motor driver.

The idea is to get as much hands on and working as possible so please
bring your arduino,freeduino,teensy,or dorkboard, a soldering iron, some wire and your
laptop and we will get our hands dirty.
I am limited to 25 on this one so please RSVP as soon as possible.

http://tempusdictum.com/tdproducts.html

This will be in room 205 at PNCA (NW 12th and Johnson) from 1-5 pm.

Arduino Cult Induction, Techshop Session. 11 October 2009

feurig — Tue, 06 Oct 2009 18:31:25 -0500

http://opentechspace.org/2009/09/21/arduino-cult-induction-workshop-1-5pm-oct-11/

5 lines about 36 Blinking Lights.

feurig — Wed, 16 Sep 2009 19:59:01 -0500

A while back I started thinking about a way to display stationary bike race results that didn't require either a projector or a really complicated mechanical assembly. The thing that came to mind was a race tree like at the drag races. I asked Amanda who has been running bike events in portland if she could get me 12 lights. I wound up with pile of Bike Planet lights which required about a weeks worth of surgery.

From one of our led driving discussions a few years back I wound up with a tube of 74hc595s which I wired up like so.

While there are examples using bit banging to drive shift registers with the arduino they ignore the built in hardware capabilities of the AVR family.

Using the built in spi greatly simplifies your code and is remarkably fast. In the code sample below there are 5 bytes which represent the 40 pins from 5 shift registers. The main loop just toggles the bits and sends them out the door.

byte outbytes[5]={0x55,0x55,0x55,0x55,0x55};
//uncomment this for a standard arduino
//#define PIN_SCK          13             // SPI clock (also Arduino LED!)
//#define PIN_MISO         12             // SPI data input
//#define PIN_MOSI         11             // SPI data output#define PIN_HEARTBEAT     7           // added LED
#define PIN_SCK          9           // SPI clock (also Arduino LED!)
#define PIN_MISO         11            // SPI data input
#define PIN_MOSI         10          // SPI data output
#define PIN_SS         8             // SPI slave select

void EnableSPI(void) {
SPCR |= 1 << SPE;
}

void DisableSPI(void) {
SPCR &= ~(1 << SPE);
}

byte SendRecSPI(byte Dbyte) {             // send one byte, get another in exchange
SPDR = Dbyte;
while (! (SPSR & (1 << SPIF))) {
continue;
}
return SPDR;                             // SPIF will be cleared
}

void RunShiftRegister(void) {
byte bitBucket;
int i;
digitalWrite(PIN_SS,HIGH);
EnableSPI();                             // turn on the SPI hardware
for (i=0; i<5; i++) {
bitBucket = SendRecSPI(outbytes[i]);
}
DisableSPI();                             // return to manual control
digitalWrite(PIN_SS,LOW);

}

void setup() {

pinMode(PIN_SCK,OUTPUT);
digitalWrite(PIN_SCK,LOW);
pinMode(PIN_SS,OUTPUT);
digitalWrite(PIN_SS,HIGH);
pinMode(PIN_MOSI,OUTPUT);
digitalWrite(PIN_MOSI,LOW);
pinMode(PIN_MISO,INPUT);
digitalWrite(PIN_MISO,HIGH);

SPCR = B01110001;              // Auto SPI: no int, enable, LSB first, master, + edge, leading, f/16
SPSR = B00000000;              // not double data rate

}

void loop(){
int i;
RunShiftRegister();
for (i=0; i<5; i++){
outbytes[i]= ~outbytes[i];
}
delay(1000);
};

Simple fast and easy.

Arduino Cult Induction 30 August 1-5 pm

feurig — Tue, 25 Aug 2009 04:52:49 -0500

http://dorkbotpdx.org/workshop/arduino/cult_induction_rev7

WiiWah

feurig — Thu, 20 Aug 2009 18:39:00 -0500

WiiWah demo from Donald Delmar Davis on Vimeo.

Collin Oldham came over before my gig in Spokane last month and brought a couple of patches and a few ideas on how to set up an effects chain using pure data. One of them was a patch using something called a "Formant" filter.

Wah.

I am not going to even pretend to understand it. But when I actually got to where I could play with it, it was really subtle and I didn't like it. Then Collin explained that it needed some harmonics to work well.

Crunchy

Lucky for me Jason (breedx) showed me a really nice technique for getting distortion. Its still not as nice as my gz2 but its a pretty good demo of some of what can be done very easily in pure data.

Combining the two creates a really nice wah that is very vowel like as you can hear in the video above.

Connecting the Wiimote to pd on a mac.

My first attempt to connect to pd using the wii was using an OSC connection called musiccontroller using my intel mac. It worked though had the same issues that darwin remote has where in order to reconnect the wiimote to the you had to manually delete the binding that osx creats for the wiimote in the bluetooth control panel. The show stopper though was that it did not run on the machine I am targeting which is running tiger on a PPC.

Looking at alternatives I found a program called OSCulator which has ability to map multiple input sources and wiimotes, connects to the wiimote consistantly and with very little intervention and it has an extremely flexible mapping system for both osc and midi (though I never did get the osc part to work). It was however was neither open source nor free.

The solution I wound up with both simple and straight forward. It uses an open source application called wiitomidi and OSX's IAC loopback device.

The pd source for all the patches put together is attached here. (http://dorkbotpdx.org/files/wiiwah.tgz)

Bumblebenito

feurig — Fri, 14 Aug 2009 17:02:50 -0500

When I created the Benito I was working on a specific need for an arduino "programmer". Since then several products have come out which are comparable and in some cases less expensive than the manual labor it takes me to build out and program the boards. One of these is the bumble-b. from Dave Fletcher. For this months arduino cult induction I will be evaluating the bumble-b as a possible replacement.

If you want to check out the bumble-b yourself I have 20 of them at a dorkbotpdx introductory rate of $10 which I will bring to Monday's meeting.

Buttons and sliders and stompswitches oh my!

feurig — Tue, 28 Jul 2009 01:14:43 -0500

When I first built the box above I was trying to overcome the things I disliked about one of my better effect systems. It is a zoom bass pedal with several programmable subsystems (reverb/delay/distortion/a couple of lfos and filters) which you put together using an amazingly arcane system to get a huge variety of sounds. Of course once you unplug it it looses your programming and you are left with the factory presets. Which once you get over your loss isn't so bad in itself since about a fifth of the "stock" sounds are all you would ever need. The thing that stinks is hunting and pecking for them.

I wanted to put together using pure data a similar "set" of sounds that I could select, combine and adjust easily. I started with a 4 button/slider prototype and laid out a 16 button/slider board which I managed to mess up in the gimp as to make it unusable.

So I put the prototype into production. I recycled the box that I originally tried to put all of the imic / gk-3 interface into (a disaster at best probably never to be explained before blowing up a mini itx motherboard in an attempt build out an audiopint, so it goes) and mounted everything as below.

All of the pots and lighted switches are actual musical instrument components. For the stomp switches I used the same interface (rca jacks) that the switches originally used to select effects on an old tube amp. For the expression I used an unmodified volume/pan peddle.

Then I went about getting it interfaced to pure data.

The easiest path to this was using Paul Stoffregon's fresh port of firmata and a teensy++. I chose this because there are ample examples and it is established. Because the arduino is by default stupidly serial only I knew that I would be moving up the chain to something more usable like usb native midi but I didn't have time to write the underlying firmware and then figure out how to use it to control pd.

Firmata delivered what it was supposed to with a few exceptions.

No debounce on the switches.
No pullups on the inputs.
Its noisy and puts a lot of data out.

The first two were easy enough to fix. There is a de-bounce abstraction in pd extended that more or less works and I added the pullups to the input setup in the firmata. I would run this back up the source but first of all this is not the best solution and the last issue was pretty much a showstopper. There is a lot of meticulous work in the firmata library designed specifically to get data out quickly and when you combine that with a usb/serial implimentation that is not limited by actual serial speeds the result is a *lot* of data (95 percent of which you dont need). On a 2.1 Ghz macbook with 4 gig of memory, a noisy potentiometer would actually put out enough data to where there were audible glitches in the sound.

So I started looking at alternatives including Collin Oldham's recent blog post (http://www.dorkbotpdx.org/blog/coldham/pd_and_arduino_or_whatever_you_ca...) until I found the link below.

http://kiilo.org/tiki/tiki-index.php?page=Arduino-PureData-MessageSystem

It wasnt perfect but it was close enough that I was able to make it fit my needs in a little over a day of hacking at it (with a little help from my friends of course).

The teensyduino code and the

pd patch are attached below.

Fabrication Workshop Followup.

feurig — Mon, 01 Jun 2009 19:42:22 -0500

First let me thank the group of people who came on sunday for the first crack at the fabrication and circuit board workshop. I realize that we spent a lot of time in eagle and not enough time actually doing the etch process. In the future I will probably do a separate workshop for eagle alone.

For this reason I will be available Sunday at TDIs workshop at 833 SE Main #125 for any of yesterdays participants who would like to go over the process of etching the board again and to get some hands on practice.

You are also welcome to come to the TechShop session on june 14th (before carpooling to the dorkbot event at about us).

I have also uploaded the folder with the Anderton superfuzz design files ( http://dorkbotpdx.org/files/fabclass.zip ) and the hobby design rules You should try to run the drc error check and you should notice that with the wider pads a few of the parts will need to be moved.

The 1458 can be replaced with any of the following low noise equivalents (the lt and ne parts are spendy).

For those of you who missed the session because you were away there will be a second session at techshop in the afternoon before the evenings event at about us.