everhack Stuff I've been messing with, or just thinking about.


Taking a break from electronics, back to my original love, old BMWs.

I've decided to take a break from electronics and get back into old BMWs; a love of mine since right after high school when I thought I was going to be a mechanic for a living.

So, I bought this gray market 1979 BMW 323i that desperately needed a new and loving home to nurse it back to health.

IMG_5208 (Medium)

IMG_5334 (Medium)

Filed under: Uncategorized 2 Comments

fireflies redux

Just a little toy circuit I can't stop playing with...



Filed under: Uncategorized No Comments

Shape Packing

Here's a totally awesome GIMP plugin I discovered fortuitously over the weekend, "pack sprites", which is included with excellent "GREYC's Magic for Image Computing" (G'MIC) framework.

Forum announcement with lots of examples (it was called "pack shapes" at first)

New filter 'Patterns / Pack shape'

G'MIC homepage:


I'm using it to create semi-random lightening hole patterns for a laser-cut dulcimer fretboard I'm designing.


Filed under: Uncategorized No Comments

The Impending Digital Photo Apocalyse


The impending "digital photograph apocalypse" that I've been anticipating since 2003.. Googling the subject you can find articles and blog posts every year since then warning about it (but not many).

(see archiving, digital vs. film)

As digital photography displaces film photography, while at the same time bitrot and lax backup strategies slowly and quietly destroy those precious zillions of photos of cats, delicious meals-about-to-be-eaten, and Kayden/Aidan/Kieran's first tentative finger paintings in poo.

People will one day wake up and realize it's all gone.

Their CD-Rs tossed in a shoebox don't read anymore..

that new computer doesn't support that old Photo-CD format,

The budget online backup service got bought by some startup and then went bankrupt two weeks later after the CFO stole all the money and went AWOL...

Just check out the lengths a small dedicated team from NASA had to go to recover some early lunar orbiter tapes: Lunar Orbiter data recovery

Those boxes of film negatives? Just fine unless they got mildew on them.

It hasn't happened on any large scale yet, but as the transition slider moves ever further into the "all digital" realm and we get more and more casual with our terabytes of data, the risk rises ever higher in my opinion.

It seems so obvious to me that a high speed, high quality consumer grade film recorder, and accompanying "cloud to film" backup provider would make a mint.

Go ahead, search eBay for any such thing. All you'll find are machines that are ten years old or more older, with SCSI interfaces and software that's no longer available or supported on modern OS's.

The services out there (if you can find them) are ridiculously expensive. ($2.50-$4 PER IMAGE!!)

What if you could designate a particular folder in your Carbonite or Amazon or Backblaze backup as "backup to film and mail me the negatives for 0.10 a shot?" (see Pro Photo Connection) - ironically, this works out even cheaper than doing it yourself (my back of the envelope calculation works out to about 0.12 cents per exposure...)

Or have a nice desktop unit that you drop a roll of film in, push "print" and within 30 minutes (or better yet, 30 seconds), have 32 exposures safely ready to send out for development. Very affordable if you don't bother getting them printed, or maybe just a contact sheet.

Then again.. I suppose all of this requires a little planning and forethought, and if you had the benefit of those things maybe you wouldn't be one of those unlucky millions of people facing the "digital photo apocalypse" to start with.


Filed under: Uncategorized No Comments

LED as a light sensor

This is nothing new, but it's still pretty neat. Using a LED as a light sensor.

I modded this demo code from the Blinkenlight blog to read just one LED as input and turn a second LED on and off based on a simple threshold.



// www.blinkenlight.net
// Copyright 2011 Udo Klein
// modded 2013 by david mitchell - turn an LED on and off based on the light sensor value
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see http://www.gnu.org/licenses/

// Usage
// This sketch uses the Blinkenlight Shield as a light
// sensor. In order to make this work jumper the shield
// such the common cathode of the LEDs it connected
// to +5V.
// It will output hexadecimal digits that correspond
// to the amount of light captured by the LEDs.
// 0 = very bright light
// higher numbers = less light
// Theory of operation
// For each LED the following happens:

// 1) The PIN is pulled low thus reversing the LED.
// Thus the LED will act like a capacitor and gets
// charged.
// 2) We store the current milli second count in
// start_millis for later use.
// 3) The PIN is put to high Z input and starts to
// "float" with the voltage of the "LED cap".
// 4) If the LED captures light the "LED cap" will
// discharge fast, otherwise it discharges slow.
// 5) As the cap discharges the input PIN will
// float high.
// 6) Once the pin is detected to be high we will
// compute elapsed_millis by subtracting
// start_millis from the current milli second
// count

// The loops are coded in such a way that this
// happens "in parallel". They are also coded
// in such a way that each pin gets some time
// to settle.

// used to store the start milli second count per pin
uint16_t start_millis[1];
// used to store the last computed milli second count when pin floated to high
uint16_t elapsed_millis[1];

uint8_t transform(uint16_t data) {
// output transformation, used to map uint16_t to 1 hex digit
// basically a logarithm to the base of 2
uint8_t i=0;
while (data) {
data >>= 1;
return i;

boolean pin_is_ok(uint8_t pin) {
// used to determine which pins are good for light detection
// pins 0,1 are spoiled by the serial port
// pin 13 is spoiled by the Arduino's LED
return (pin == 5);
#define MINPIN 5
#define MAXPIN 5
#define ANODE_POWER 6

#define LED_OUT 7

void setup() {

digitalWrite(LED_OUT, HIGH);

// turn on the LED charge power
digitalWrite(ANODE_POWER, HIGH);

for (uint8_t pin = MINPIN; pin <= MAXPIN; ++pin) if (pin_is_ok(pin)) { pinMode(pin, OUTPUT); digitalWrite(pin, LOW); start_millis[pin] = millis(); elapsed_millis[pin] = 0; } for (uint8_t pin = MINPIN; pin <= MAXPIN; ++pin) if (pin_is_ok(pin)) { pinMode(pin, INPUT); } } void loop() { for (uint8_t pin = MINPIN; pin <= MAXPIN; ++pin) if (pin_is_ok(pin)) { if (digitalRead(pin)) { pinMode(pin, OUTPUT); elapsed_millis[pin] = millis()-start_millis[pin]; start_millis[pin] = millis(); pinMode(pin, INPUT); } } for (uint8_t pin = MINPIN; pin <= MAXPIN; ++pin) if (pin_is_ok(pin)) { int diff = transform(elapsed_millis[pin]); if (diff > 6) {
digitalWrite(LED_OUT, HIGH);
else {
digitalWrite(LED_OUT, LOW);
Serial.print(diff, HEX);

Tagged as: , No Comments

How my Dulcimers turned out

Well, after a long delay, I'm finally back to post some updates.

It took me about a month, but I finished building my dulcimer around May of last year, and it turned out really nice! I've been playing for almost a year now and really having a great time with it.


Here's another photo of it, hanging next to the one my dad made as a wedding gift for my mom in 1964.

Between them is an experimental one I made from HDF (hardboard). I wanted to know if I could make one completely from laser-cut pieces.

The answer is yes, but that HDF is a lousy tonewood. I ended up bandsawing it in half in a fit of frustration and discovered it makes a very nice wall hanger.


Here's another one of the HDF dulcimer.. I love the design of it, my next real dulcimer will look very similar, but I'll use a pegbox more like the one my dad made (like on the teardrop dulcimer above).








Filed under: Uncategorized No Comments

The Mountain Dulcimer : how to make it and play it (after a fashion)

Back in the late 50's and early 60's, my dad started building and playing Appalachian (mountain) dulcimers. Being the teacher and playful maker he is, he soon wrote a pamphlet on the subject that he shared with his students and anyone who wrote to ask about it.

Here's a copy of his 1962 (second edition) pamphlet, "The Mountain Dulcimer, how to make and play it (after a fashion)", which he has generously given me permission to post here for public consumption.

This pamphlet is the basis for the 1965 Folk Legacy book & album of the same title, but there are many differences between the two.

The Mountain Dulcimer, 2nd ed.

I had a nice long chat with Caroline Paton (of Folk Legacy Records) and she has generously given permission for me to publicly share a PDF of the Folk Legacy book, "The Mountain Dulcimer - How to Make it and Play it (after a fashion).". This is a significantly revised and lengthened version of the pamphlet, with a wonderful companion recording.

The Mountain Dulcimer - Part 1

The Mountain Dulcimer - Part 2

The CD is still available from Folk Legacy's website at:

The books, CDs, and original LPs are also pretty easy to find on eBay and Amazon.

The pamphlet focuses on the 3-string dulcimer and has quite a few more specific measurements than the book. The book mostly covers the 4-string dulcimer, but discusses a number of variations.

Enjoy and share with the blessings of Howie, Ann, Caroline and myself. I just love the way he encourages experimentation and presents the topics in such a clear and light-hearted fashion, it should appeal to most anyone with a creative streak, even if you never plan to actually make, or play, your own dulcimer.

I recommend both!

And yes, I finally decided to try building one for myself. Here's what mine looks like so far 🙂

Filed under: Uncategorized No Comments

RFID Reader wrapup

I realized I never posted any images of my RFID reader in action, so here's a few of how it looks today in action.

This first view is of my workbench with scope, logic analyzer, reader & tag, and a few of my homemade tags.

Here's a closeup of the reader itself. The USB cable and antenna are the only connections required. The LED flashes every time the code recognizes the "triple-0" tag header sequence.

I have my 4 scope probes hooked up to the following signals from bottom to top.

First is a closeup view of just a couple of bits from the signal, showing the bits modulated with the 125khz carrier.

4) This is the antenna input signal after passing through the detector diode, low-pass filter, and decoupling capacitor.

3) The noisy line near the top of the antenna signal is the threshold voltage, which is adjusted manually to a couple hundred mV via a simple potentiometer / voltage divider. These two signals are fed into the AVR's built-in analog comparator to produce interrupts whenever the antenna signal rises above the threshold.

1) This the raw manchester-encoded signal from the tag as output by the detector code. It's composed of sequences of 5 possible signals, "short low", "double low", "triple low (this is the start-flag)", "short high", and "double high". You can see the how the trace echoes the signal in the antenna, delayed by 1/2 the length of a "short", which is how long the timer takes to detect the end of a high or low.

2) The topmost trace is what I use for triggering the scope, it's always low except when the tag header (000) is detected.

The next view is zoomed out a bit, showing the trigger pulse on channel 2, and the first 8 or 9 bits of the signal on channel 1.

Here's the two logic signals as seen via the Saleae Logic, and underneath are the (slightly obscured) decoded tag values output to the serial port.

Here's the schematic:

And, last but not least, the code itself (This is Arduino code for Teensy 2.0)

Filed under: Uncategorized 3 Comments

Fixed my Oscilloscope

Several months ago I picked up a Tektronix TDS 640, 4-channel 500mhz oscilloscope at a hamfest for $50.

It was failing several of the power-on self tests with some mysterious errors like "FAIL ++ Acquisition" and "FAIL ++ Attn/Acq interface". After my successes repairing Cricuts and resurrecting my first $20 analog scope with a bunch of Deoxit spray I figured I'd get my money's worth of entertainment out of it.

Googling the subject quickly revealed this as the inevitable consequence of "Capacitor Plague." It seems the original SMD electrolytic capacitors all end up leaking corrosive gases and goo onto the circuit boards, which, if not cleaned up in time, eventually results in assorted broken vias and board traces. The visible result of all this is these failed self-tests.

The Tektronix Community Oscilloscope Technical Support Forum, fortunately, has accumulated quite a few threads over time with information and various troubleshooting & repair tips for this issue.

So after a couple of months of building up my courage, buying a ESD-safe temp-controlled iron, antistatic work mat, and desoldering "hot tweezers", I was ready!

I started out by practicing desoldering and resoldering a bunch of similar SMD caps on a handful of old busted PC graphics cards from the pile on the hack shelf.

Removing all the old caps turned out to be pretty easy. As it turns out, and it's hard to believe this until you try it out, the best way to remove the old parts is actually to press down and gently wiggle the part right off. The copper leads work-harden and snap off without stressing the underlying solder pad one bit. After I learned about this method I practiced it a dozen times to prove to myself that it was actually the LEAST damaging way to get them off there. (The corroded old solder doesn't take heat well).

Fast forward to last week, I'd ordered in and received all the new capacitors and was ready to dig in.

After removing all 100 or so old caps on 3 circuit boards, the next thing was to use a combination of solder sucker, iron, and desoldering braid to remove all the old solder and remnants of broken leads, leaving the solder pads as clean as possible.

Once this is done, you super clean the entire board with a toothbrush and full strength Simple Green, rinse in the sink under super hot water. Bake in the oven at 125 degrees for an hour or two, followed by an Isopropanol rinse, and another overnight drying period in a warm place.

The resoldering process follows by putting some flux on all the solder pads, and melting a little pillow of solder on each one. Since the caps are polarized, you need to take care to orient the new one properly, but on this scope the process is super easy because nearly every single one is oriented in the same direction, and all but one pad is marked with a +.

Soldering the cap goes like this: use the iron to melt the solder pillow on one pad, and, just using your fingers, hold the cap in place. Touch the iron to the lead and stay long enough to make sure it bonds properly (too quick and you'll get a cold-solder joint). The cap will be attached on one side now, and slightly cocked due to the unmelted pillow under the other lead. To finish soldering, just press down lightly with one finger while heating up the lead. When the solder melts, you'll feel the part move downwards until it's fully seated on the board.

Now, just repeat this process 100 times 🙂 🙂 It sounds like a really big job, but after the first few dozen it goes very quickly. The whole process excluding drying time only took a few hours.

At this point, I was eager to fire up the scope and see if those darn errors went away. Annnnnnd... no change! Arrgh!

Going back to the Tek Forum, I learned that the reason for this was almost certainly due to some combination of corroded vias, broken traces, or fried components.

The way to start finding these is to use the voltmeter and, with the machine running, carefully check the voltage across all the capacitors and make sure they are all about 5 or 15 volts. Similarly, check the voltages across the power & ground leads to all the dozen or so opamp chips on the board to make sure they are also similarly valued.

In my case, I found one opamp chip with a bad ground, and one capacitor with only 1 volt across it instead of 5. Both problems ended up being due to a broken via, and were fixable by carefully determining exactly where the broken lead went to and soldering on a tiny little 30-gauge jumper wire to bridge the gap. (tracing the connections can be a little tricky with a multilayer board like this)...

After a couple rounds of probing and probing and installing the two jumper wires, I fired the scope back up... and YES, the self test passes completely now, and the formerly failing Signal Path Compensation routine also passes.

Filed under: Uncategorized 2 Comments

Sniffer Nano 2.0

Now that I understand how it all works, here's a much nicer looking version of my reader. It's the $20 Sniffer Nano 2.0 - a nice SMD AVR168 design on a daughterboard, powered by arduino sketch.. Glad I didn't discover this one earlier, it might have ruined all the fun 🙂


here's the code:

Filed under: Uncategorized No Comments