Crabtacular Bacon Dip

• 8 oz cream cheese, softened
• 1/2 C mayonnaise
• 6 oz shredded cheese (sharp cheddar and pepperjack have both worked well)
• 1/2 C (or so) grated asiago or parmesan cheese
• 8 oz bacon, cooked and finely chopped
• meat of a large dungeoness crab, cooked and cleaned
• 1/2 of a 14 oz can of diced tomatoes, very well drained (downright wrung out) and finely chopped
• 4 scallions, finely chopped
• 1/4 onion, cooked over medium heat with a spoonful of bacon drippings until soft and translucent
• Seasonings to taste – I think I used Worcestershire sauce, fresh ground pepper, kosher and / or truffle salt, onion powder, Beau Monde,  Old Bay, cayanne… make it up, taste frequently, try to have a theme and don’t overpower the crab (but there should be a lot of crab meat and bacon has flavor aplenty)
• Ritz crackers to crumble on top (and dispose of any excess dip)

Apologies to Zappa this time.  The other day I bought a small LED dynamo flashlight; I was curious about the implementation details and how much power it actually generates.  Turns out the dynamo appears to be a very common sort of DC motor and, while it doesn’t appear to produce a lot of power, it does seem to be a usable amount for a variety of low-power applications.

First peek: it’s geared up quite a lot; speaking of quite a lot, there’s some silicone grease in there too…

The dynamo motor appears to be identical to the one that drives the tray mechanism of every CD or DVD drive I’ve ever taken apart. (Not just physically, I got similar voltages from finger-spinning each of them)

Starting from the left: a bridge rectifier so it doesn’t matter which way you turn the crank, the resistor that (I believe) limits the charging current into the battery, the flashlight / charge switch (yup, you gotta crank in the dark), the LEDs and their current-limiting resistor, and finally a cute little 3-cell NiMH battery pack.

The bottom of the circuit, showing the traces.

Sooner or later, I’m going to play with dynamos again, they seem like a great way to power small projects, need to learn more about battery charging first though.

some displays

some headers

a few protoboards

and a pile of other great stuff

I’m not telling what I added, I’m not even going to give hints (and only partly ‘cos I haven’t picked out what I’m adding yet) but I will say the next person is probably going to have to either take out more than they add or split the box into two; I have quite a lot of great junk!

At some point I’d like to write up a tutorial series, but this article belongs somewhere around lesson 4 or 5.  If you’re just starting out, you’re welcome to dive in here, just be aware that it’s not really intended as a first project.  I assume at least some familiarity with C, microcontroller concepts and schematics.  I comment my code quite liberally and intend that to provide detailed explanations; what follows here is meant to provide some high-level descriptions and references for the major facets of the project and I recommend opening the code and schematic files below and referring to them as you read this.

My copy of X11 got pooched so I sketched the schematic in Create: ThereAndBackSchematic.pdf (did I mention I desperately want a native Mac OS X schematic editor?); the code to drive it: ThereAndBack.c; helpers: bit_helpers.h, avrbuild, avrpush

The circuit is pretty straightforward: a couple of buttons, “Go” tells the servo to go to the other position, “Set” switches into or out of set-mode; a potentiometer acts as a variable voltage divider, feeding an analog-to-digital converter input a voltage between ~0 and ~Vcc (plus it has a couple of extra resistors to limit current at the extremes); some LEDs to display the approximate value being read by the ADC because blinky lights rock; and finally, a standard hobby servo, I’m using a Futaba S3003 because it’s cheap and reasonably strong.  I have been powering the circuit from a USB port via my (patched) USBtinyISP or with 3 AA batteries, but I have not been putting any load on the servo; note that the stall current is pretty close to the 500ma USB spec, so the batteries are the (slightly) safer alternative.

The code depends on a collection of bit manipulation convenience macros I’ve accumulated into bit_helpers.h.  The switches are debounced with a vertical stack counter (thanks, Bill!)  Both the ADC and timer are flexible but complex peripherals, requiring a fair amount of setup and configuration to have them do what you want. This page helped me a lot with understanding and using timers for pulse-width modulation and servos, the ADC I mostly had to piece together from the datasheet.  Fortunately, both can be really easy to use once you have their 10-or-so lines of setup: just set the right OCR register to adjust the width of the pulse that controls the servo or read the ADCH register to get the most recent converted value.  Finally, to make it remember the set positions even if it loses power, I followed this tutorial for the use of EEMEM / eeprom_read_byte, though it kinda glosses over loading the initial values into the chip.  The first step is to copy the eeprom data out of the .elf file with another avr-objcopy step: 

avr-objcopy -j .eeprom --set-section-flags=.eeprom="alloc,load" --change-section-lma .eeprom=0 -O ihex $ElfFile $EepFile

and push it to the chip with an extra -U to avrdude: 

-U eeprom:w:$EepFile

 I added those lines to the shell scripts I use to build avr projects and push them through to the chips (linked above.)

Finally, a couple notes on using it: when it powers on or goes into set-mode, it always starts in position A. When setting a new pair of positions, if the potentiometer is still where you left it after programming position B last time, the servo will move to that position, nevertheless it is setting position A. Also, when setting the positions the “Go” button still simply switches to the other position; in general, you want to hit “Set”, dial in position A, hit “Go”, dial in position B, then hit “Set” again (if you hit “Go” again after setting position B, you’re back to setting position A which will immediately get the current value from the ADC.)

Installation:  EAGLE’s installation was pretty reasonable; a reasonably quick download, a quick install script and weighs in around 40 MB.  gEDA, on the other hand is, for OS X, only available as a Fink package; I much prefer MacPorts, so I had to install Fink solely to install gEDA and the whole process took about 5 hours and takes up over 1.4 GB – Ouch.

Capabilities: EAGLE is just for schematic and circuit board layout, and those capabilities are handicapped in the free version; gEDA aims to be a full suite of open-source electronic design tools.  However I don’t need many of the things gEDA brings along and EAGLE Light’s limitations are not terribly onerous.  Both have substantial libraries of parts, and gEDA has an online parts repository (which currently requires URL-hacking to use, webmaster has been notified).

Usage: Both have some similar user interface paradigms, but I find gEDA’s to be slightly cleaner and the keyboard shortcuts are much better: ’s’ for “Select mode”, ‘n’ for “Net mode”, whereas EAGLE uses the F-keys. (In addition to being non-mnemonic, my F-keys are all taken up with things like mute, keyboad brightness, and Exposé.) Also, despite turning on “emulate 3-button mouse”, I couldn’t figure out how to select multiple items in EAGLE, but it’s very natural in gEDA (though it does not give good visual indication of selection, so maybe I got it and just missed it).  I don’t like gEDA’s black background, but that can be fixed.  I like that EAGLE previews the board footprint of parts when searching, though I had inconstant success getting the part to the page and the part picker goes away when you switch to doing something else and it doesn’t remember where you left the window.  gEDA’s part picker window acts more like the “palate” I expect makes it easer to switch back-and-forth between adding parts and connecting them.  Finally, I found exporting to PostScript slightly easier from gEDA (and EAGLE does not appear to support printing the 8.5″ x 11″ US Letter size, odd).

Today, I reorganized my personal svn repository to the vastly superior, in my experience, top-level Trunk / Branches layout and started looking into building a usb datalogger based on the EasyLogger, though I’d like to use the EMSL board (ATmega168-based) and be able to log more than one input, but I need to either figure out if it has the right internal oscillator or get an external clock.