Pete's Blog

Learning to fly and Perl for METAR Decoding

2013-02-16T11:20:00.002-05:00

One of the ways I have been occupying myself is with flight training for a private pilot license or more correctly called a private pilot certificate. It's been off and on lately because I have had to take some time off to focus on other projects, but next month I will be resuming at as fast of a pace as my pocketbook will allow. Since I needed some pilot/flying related activities to keep my interest during this down time I decided to write a Perl parsing script for aviation weather reports called METAR's. But, first how did I find myself in the left seat of an airplane for the first time? Well, read on.

About a year ago as a birthday present I was given a "discovery flight" by my parents. A discovery flight is where a certified flight instructor sticks you in the pilot seat, guides you to take off and fly a plane around for about an hour before landing at the airport where you took off from. This is akin to the "visitation" rooms at the humane society where they let you play with the puppies and cats, all the while knowing that the puppy ( or aircraft, rather ) that you have been playing with is soon to become your highest priority.

That's how it happened with me anyway. On my discovery flight I pushed the throttle forward. We soon accelerated to 50 knots and when I pulled the yoke toward my chest, the Cessna 152 parted the runway and I became speechless; my breath had been taken thru amazement of the reality of flight. It is one thing to understand the physics of flight and totally different to experience it. General aviation or small aircraft flight isn't anything like the experience of large commercial airplanes.

In fact, I was so taken by this flying that I decided to continue flight lessons, working towards a private pilot certificate. As I mentioned above I have experienced quite a few training delays along the way including taking time off to start Lakeside Electronics, LLC, so in the interim I wanted to come up with some activities related to flying.

Early on in my flight training I recognized the impact and importance of weather on general aviation or I should say, aviation in general. There are even aviation specific weather reports such as METARs that pilots access for preflight weather planning. You can look up a report for an airport near you using their ICAO station identifier code here http://aviationweather.gov/adds/metars/.

Here is an example METAR string from the airport I fly out of in Ann Arbor, Michigan: KARB 021653Z 34015G23KT 10SM OVC033 04/M03 A2996 RMK AO2 SLP150 T00441033.

As you read the above report you can probably make out what some of the sub-strings mean. For example, before researching I postulated that " OVC033 " meant overcast, but I did not fathom that the second half was referring to cloud height in 100's of feet. Could " SLP150 " be something to do with slip? Nope, Sea Level Pressure - in tens, units and tenths to be added to 1000 hPa no less. In other words, 15.0 hPa + 1000 hPa = 1015.0 hPa. However, if the string were a high number like SLP965 you would add that value ( 96.5hPa ) to 900 hPa instead for a reading of 996.5 hPa. Yes, its a strange little protocol...

Almost certainly I needed to study up on how to interpret this METAR report. Fortuitously, it would seem, I had concurrently begun learning the programming language Perl. A perfect storm, it would seem, to write a Perl based parsing script for METAR weather reports and display these data in a more human readable format was afoot.

The goal of course is two fold. A) To learn Perl and B) to memorize a method of METAR interpretation for when I need to read the raw string. Quite obviously there are numerable ways to accomplish these tasks. There also exists METAR decoders and even a Perl Module for this task, but this would violate my goals as set forth and thus decided to write my own Perl METAR parsing script.

When I turned to Google for information about the METAR protocol I found this page http://www.met.tamu.edu/class/metar/quick-metar.html helpful indeed. If you recall, we discussed the sub-string for sea level pressure above. There are too, other little gotchas along the way when trying to programmatically decode METAR reports. For instance, some data are always reported, some data are optionally reported and within the raw string as a whole, the sometimes reported data is intermingled with the always reported data. I also have reason to believe that the information contained in the remarks ( RMK ) section can partially exist as plain English, and so that is where my parsing stops - before we get to the optional remarks. I may look into further coding of the remarks, but for now I am satisfied with the script.

This Perl script uses Curl to fetch a METAR string from weather.noaa.gov. Then it parses the string, does some formatting and a couple of calculations for Celsius to Fahrenheit conversion then writes the data to a text file. Using a program on my macbook called GeekTools I am able to display the contents of the Perl generated text file on my desktop. It looks like this on my desktop.

Before continuing, I must say that you shouldn't use this script for flight planning and also, that it is largely untested. Please report any bugs that you may find. Part of my ongoing memorization of METAR syntax is to read the string and my scripts output and look for errors.

If you want to play along, install Geektools from the link in the previous paragraph. You will also want to copy the Perl script from below. Save the Perl script in a folder somewhere on your computer. I named my folder "metar" and located in ~/Documents/Weather/. Start up GeekTools and configure like so...

The command in the above screen cap is "cat ~/Documents/Weather/metar/metar_datafile.txt" without quotes. Change this as required for your particular path and file name.

Below is the code. It is definitely a work in progress. Every time I spot an error I correct it but I haven't seen any errors in a while now. Let me know if you do.

  
#!/usr/bin/perl -w

# this program gathers METAR data from NOAA, decodes it and does some formatting before writing the data to a text file
# this file is monitored and displayed on my macbook desktop using GeekTools
#
# Under no circumstances should you use this for flight planning.  Also, no guarantee is made that this software even works at all.
#
# Below is an example of the metar_datafile.txt after the curl command.  There are 2 lines as you can see.
#
# 2012/10/27 11:53
# KARB 300153Z AUTO 35018G34KT 10SM OVC095 06/M05 A2978 RMK AO2 PK WND 35034/0144 SLP090 T00561050
#
#

#while( 1 ){
my $ICAO_STATION = "KARB"; # airport nearby

my $raw_metar_data = `curl --silent http://weather.noaa.gov/pub/data/observations/metar/stations/$ICAO_STATION.TXT`;

chomp $raw_metar_data;

my  ( $date_time, $current_metar_line ) = split /\n/,$raw_metar_data;

chomp $date_time;
chomp $current_metar_line;

# put the METAR string into an array 
my @metar_array = split / /, $current_metar_line;
my $array_index = 0;

open (MYFILE, '>metar_datafile.txt'); #open for write >> would be for apend

#
# print the full array we are about to decode separated by spaces
print MYFILE "@metar_array\n";

#
# print the station ID as read
print MYFILE "ICAO Station ID: $metar_array[ $array_index ]\n";
++$array_index;

#
# print the day of the metar transmission
my $day = substr( $metar_array[ $array_index ], 0, 2 );
print MYFILE "Day: $day";

# print ^st, ^nd, ^rd or ^th at the end of the date just for a bit of fun
#my $right_digit = substr( $day, 1, 1 );

#$day = "3";



if( ( scalar $day == 1 ) || ( scalar $day == 21 ) || ( scalar $day == 31 ) ){
 print MYFILE "st\n";
}
elsif( ( scalar $day == 2 ) || ( scalar $day == 22 ) ){
 print MYFILE "nd\n";
}
elsif( ( scalar $day == 3 ) || ( scalar $day == 23 ) ){
 print MYFILE "rd\n";
}else{
 print MYFILE "th\n";
}


#
# print the time of the metar transmission in zulu time aka 0 GMT
my $zulu_hours = substr( $metar_array[ $array_index ], 2, 2 );
my $zulu_minutes = substr( $metar_array[ $array_index ], 4, 2 );
print MYFILE "Report Time ( Zulu ): $zulu_hours:$zulu_minutes\n";

++$array_index;


#
# decode and print report type ( auto or corrected or none )
#
# test String
# $metar_array[ $array_index ] = "COR";


if( $metar_array[ $array_index ] eq "AUTO" ){
 print MYFILE "Report Autonomy: Automatic - No human intervention.\n";
 ++$array_index;
 }
elsif( $metar_array[ $array_index ] eq "COR" ){
 print MYFILE "Report Autonomy: Corected observations.\n";
 ++$array_index;
 } 
else{
 print MYFILE "Report Autonomy: Human observer or Automatic with human oversight.\n";
}


#
# decode and print wind data

print MYFILE "Wind Condition: ";

# the first three characters are either VBR or they contain wind direction
my $wind_direction = substr( $metar_array[ $array_index ], 0, 3 );

# the next two characters always contain wind speed
my $wind_speed = substr( $metar_array[ $array_index ], 3, 2 );

if( $wind_direction eq "VBR" ){
 print MYFILE "Direction variable at $wind_speed knots.\n";
 ++$array_index;
}
# else if the string contains a 'V' for variable wind over 6 knots...
elsif( $metar_array[ $array_index ] =~ /V/ ){
 print MYFILE "Wind from $wind_direction degrees at $wind_speed knots - ";
 my $dir1 = substr( $metar_array[ $array_index ], 9, 3 );
 my $dir2 = substr( $metar_array[ $array_index ], 13, 3 );
 print MYFILE "Variable between $dir1 and $dir2 degrees.\n";
 ++$array_index;
} 
# else if the string contains a 'G' for gust
elsif( $metar_array[ $array_index ] =~ /G/ ){
 print MYFILE "Wind from $wind_direction degrees at $wind_speed knots - ";
 my $gust_speed = substr( $metar_array[ $array_index ], 6, 2 );
 print MYFILE "Gusts to $gust_speed knots.\n";
 ++$array_index; 
}
else{
 print MYFILE "Wind from $wind_direction degrees at $wind_speed knots.\n";
 ++$array_index;
}


#
# decode and print visibility

print MYFILE "Visibility: ";

# remove "SM" from the end of the string leaving the visibility in statute miles
my $visibility = $metar_array[ $array_index ];
chop $visibility;
chop $visibility;

# if the string still contains an 'M' after the chops there is a special case
if( $visibility =~ /M/ ){
 print MYFILE "Less than 1/4 statute miles.\n";
} 
elsif( $visibility eq 9999 ){
 print MYFILE "Greater than maximum recorded value.\n";
}
else{
 print MYFILE "$visibility statute miles.\n";
}
++$array_index;



#
# decode and print runway visual range if reported
# this string should contain a forward slash if it contains runway visual data
#
# test string
# $metar_array[ $array_index ] = "R16/P20000VM211FT";

if( $metar_array[ $array_index ] =~ /\// ){
 
 print MYFILE "Runway Visual Range: ";
 
 my( $runway, $range ) = split /\//, $metar_array[ $array_index ];
 
 # remove the 'R' from the runway number
 $runway =~ s/.//;
 
 # remove "FT" from the range(s)
 chop $range;
 chop $range;
 
 # there is a 'V' in $range_a if the visual range is variable
 if( $range =~ /V/ ){
  my( $range_a, $range_b ) = split /V/, $range;
  print MYFILE "Runway $runway has a visual range between ";
  
  # check for the M or P modifier
  if( $range_a =~ /M/ ){
   #remove the 'M'
   $range_a =~ s/.//;
   print MYFILE "less than $range_a and ";
  }
  elsif( $range_a =~ /P/ ){
   # remove the 'P'
   $range_a =~ s/.//;
   print MYFILE "greater than $range_a and ";
  }
  else{
   print MYFILE "$range_a and ";
  }
  
  if( $range_b =~ /M/ ){
   #remove the 'M'
   $range_b =~ s/.//;
   print MYFILE "less than $range_b feet.\n";
  }
  elsif( $range_b =~ /P/ ){
   # remove the 'P'
   $range_b =~ s/.//;
   print MYFILE "greater than $range_b feet.\n";
  }
  else{
   print MYFILE "$range_b feet.\n";
  }
  
  
  
 }
 else{
  print MYFILE "Runway $runway has a visual range of ";
  
  # check for the M or P modifier
  if( $range =~ /M/ ){
   #remove the 'M'
   $range =~ s/.//;
   print MYFILE "less than $range feet.\n";
  }
  elsif( $range =~ /P/ ){
   # remove the 'P'
   $range =~ s/.//;
   print MYFILE "greater than $range feet.\n";
  }
  else{
   print MYFILE "$range feet.\n";
  }
    
 }
 ++$array_index;
}



#
# decode and print weather phenomena if it exists
#
# test string
#$metar_array[ $array_index ] = "+RAPRTS-DRPL";

my $weather_phenom = $metar_array[ $array_index ];

# if the current string does not contain cloud cover data then it is weather phenomena

if( $weather_phenom !~ "SCK" & $weather_phenom !~ "CLR" & $weather_phenom !~ "FEW" & $weather_phenom !~ "SCT" &
 $weather_phenom !~ "BKN" & $weather_phenom !~ "OVC" & $weather_phenom !~ "VV" )
 {
  print MYFILE "Weather Phenomena: ";
  
  my $string_index = 0;
  my $string_length = length $weather_phenom;
  
  while( $string_index < $string_length ){
  
   my $sub_string = substr( $weather_phenom, $string_index, 2 ); 
   
   if( $sub_string =~ /\+/ ){    
    print MYFILE "Heavy ";
    ++$string_index;
   }
   elsif( $sub_string =~ /\-/ ){
    print MYFILE "Light ";
    ++$string_index;
   }
   #else{
   # print MYFILE "Moderate ";
   #}
   
   $sub_string = substr( $weather_phenom, $string_index, 2 );
   
   # hash lookup
   
   %weather_type = ( "VC" => "Vicinity ",
        "MI" => "Shallow ",
        "PR" => "Partial ",
        "BC" => "Patches ",
        "DR" => "Low Drifting ",
        "BL" => "Blowing ",
        "SH" => "Showers ",
        "TS" => "Thunderstorm ",
        "FZ" => "Freezing ",
        "DZ" => "Drizzle ",
        "RA" => "Rain ",
        "SN" => "Snow ",
        "SG" => "Snow grains ",
        "IC" => "Ice crystals ",
        "PL" => "Ice Pellets ",
        "GR" => "Hail ",
        "GS" => "Small hail ",
        "UP" => "Unknown ",
        "BR" => "Mist ",
        "FG" => "Fog ",
        "FU" => "Smoke ",
        "VA" => "Volcanic ash",
        "DU" => "Widespread dust ",
        "SA" => "Sand ",
        "HZ"  => "Haze ",
        "PY" => "Spray ",
        "PO" => "Well developed dust/sand swirls ",
        "SQ" => "Squalls ",
        "FC" => "Funnel clouds including tornadoes or waterspouts ",
        "SS" => "Sandstorm ",
        "DS"  =>  "Duststorm ",
        );
        
   print MYFILE "$weather_type{ $sub_string }";
   
   # see if there is another weather code
   $string_index += 2;
  }
  
  print MYFILE "\n";
  ++$array_index;
}


#
# decode and print the cloud cover data ( always present )
#
# test string
#$metar_array[ $array_index ] = "BKN120";

print MYFILE "Cloud cover: ";

# if there are multiple cloud conditions which can occur...
while( $metar_array[ $array_index ] =~ /(SCK|CLR|FEW|SCT|BKN|OVC|VV)/ ){
my $sky = 0;
my $cloud_height = 0;
 

if( $metar_array[ $array_index ] =~ /VV/ ){

 $sky = substr( $metar_array[ $array_index ], 0, 2 );
 $cloud_height = substr( $metar_array[ $array_index ], 2, 3 );
}
else{

 $sky = substr( $metar_array[ $array_index ], 0, 3 );
 $cloud_height = substr( $metar_array[ $array_index ], 3, 3 );
}


%sky_condition = ( "SCK" => "Sky Clear ",
     "CLR" => "Clear sky",
     "FEW" => "Few clouds ",
     "SCT" => "Scattered clouds ",
     "BKN" => "Broken clouds ",
     "OVC" => "Overcast clouds ",
     "VV" => "Vertical visibility ",
     );
     
print MYFILE "$sky_condition{ $sky }";

# if $sky has clouds in it then report the cloud height.
# if skies are clear, do not report cloud height

if( $sky =~ /(FEW|SCT|BKN|OVC|VV)/ ){
# cloud height is given in hundreds of feet
$cloud_height *= 100;

print MYFILE " at $cloud_height feet. ";
}
++$array_index;
}   

#
# decode and print the temperature and dewpoint ( always present )

my( $temperature_c, $dewpoint_c ) = split /\//, $metar_array[ $array_index ];

# if it is a negative number
if( $temperature_c =~ /M/ ){
 # remove the 'M' from the temperature
 $temperature_c =~ s/.//;
 $temperature_c *= -1; # and make it a negative number
}

if( $dewpoint_c =~ /M/ ){
 # remove the 'M' from the dewpoint
 $dewpoint_c =~ s/.//;
 $dewpoint_c *= -1; # and make it a negative number
}

my $temperature_f = $temperature_c * 1.8 + 32;
my $dewpoint_f = $dewpoint_c * 1.8 + 32;

print MYFILE "\nTemperature: $temperature_c degrees C / Dewpoint: $dewpoint_c degrees C.\n";
print MYFILE "Temperature: $temperature_f degrees F / Dewpoint: $dewpoint_f degrees F.\n";

++$array_index;


#
# decode and print atmospheric pressure ( always present )
#
# test_string
#$metar_array[ $array_index ] = "Q1234"; 
#$metar_array[ $array_index ] = "A1234"; 

my $atm = $metar_array[ $array_index ];

# if our pressure is reported in mb aka hPa
if(  $atm =~ /Q/ ){

 # remove the 'Q' from the pressure
 $atm =~ s/.//;
 print MYFILE "Atmospheric Pressure: $atm hPa\n";

}

# if our pressure is reported in mb aka hPa
elsif(  $atm =~ /A/ ){

 # remove the 'A' from the pressure
 $atm =~ s/.//;
 
 my $whole_inhg = substr( $atm, 0, 2 );
 my $frac_inhg = substr( $atm, 2, 2 );
 
 print MYFILE "Atmospheric Pressure: $whole_inhg.$frac_inhg inHg\n";

}

++$array_index;



#
# decode and print


close (MYFILE); 

#sleep( 60 );
#}

Ok, onward and upward. Clear for takeoff.

KD8TBW - My HAM Radio Call Sign

2012-09-12T14:39:00.000-04:00

I recently took an FCC Exam for radio broadcast privileges. I passed and as the title suggests my HAM or Amateur Radio Call Sign is KD8TBW or in the NATO Phonetic Alphabet Kilo, Delta, Eight, Tango, Bravo, Whiskey.

I decided to take the test after I reading the April 2012 issue of Nuts and Volts Magazine. On page 68 was an article on how to get your HAM license and the opening question was " If you are interested in electronics and radio communications, why aren't you a HAM? ". Well I couldn't answer that question and the article had a very compelling list of "10 things you can do as a HAM " so I set out to change my unlicensed status.

If you are wondering what HAM radio is, why you need a license or what cool things you can do as a HAM then head over to the American Radio Relay League ( ARRL ) website and take a look. You'll discover many interesting activities that becoming a HAM will open up to you such as talking to astronauts aboard the ISS, bouncing radio signals off the moon or meteor showers and fox hunts with Tape Measure Yagi Antennas for radio direction finding.

You may also discover loosely related projects that don't require a HAM radio license. For instance, together with my Dad, we have recently begun construction of a Quadrifilar Helicoidal Antenna for recieving APT messages from NOAA Weather Satellites, but more on that one in a later post.

I'm still pretty wet behind the ears with all this HAM radio stuff, but it is providing a good bit of entertainment so far. I picked up a Kenwood TH-F6A Radio and I even joined a local HAM radio club called ARROW Communications in Ann Arbor. I'm pretty sure I want to get into a mobile radio for my car so let me know if you have any suggestions on mobile setups.

Thor - A Programmable Brake Light Modulator

2012-09-04T09:19:00.000-04:00

I have been rather busy developing products for my new company Lakeside Electronics, LLC and as such, haven't had much time to post anything in the way of projects over here. This is OK however, because despite the massive amount of work involved in bringing a product like Thor to market, it turns out to be pretty fun too.

Of course, I still have a few irons in the hobby fire, and with Halloween coming up there are bound to be some scary, or at a minimum, vaguely direful ideas cropping up in my yet-to-be-zombified mind. But, first, I have some microcontrollers to program for a Boy Scout Troop. I was recently contacted by (them) and I am quite pleased to help them out making Halloween Spooky Eyes. Anytime someone is interested in learning new things I think it is fantastic.

Ok, so back to Thor - A Programmable Brake Light Modulator and Lakeside Electronics. If you have been reading my recent posts you are probably already aware of what a brake light modulator is. If you have any feedback, I'd like to hear it.

And finally here is the video for Thor.

More Flashing Brake Lights

2012-08-01T21:20:00.000-04:00

It seems like summer is the season for brake light flashers and Greg, a reader of Pete's Blog just emailed me to show me what he has been up to. After reading my original post Tenty LED Brake Lights which is a brake light modulator and LED light engine integrated onto perf board, Greg set out to make a version for his Yamaha V-Star 1100.

I'm impressed with Greg's craftsmanship which you can see in the photos below, but what you can't see is that he used an Arduino to program the ATTiny85 with the original code which can be found here. This is cool because if you have an Arduino laying around, but no programmer, you can still make a modulating LED brake light for yourself. Greg said the following links were useful to him in using his Arduino as a programmer http://hlt.media.mit.edu/?p=1229 and http://hlt.media.mit.edu/?p=1695 but ended up not changing the default 1 Mhz clock on the ATTiny85 and instead changed the delay between flashes in the code from 25 mS to 75 milliseconds.

Have a look at video and pics below to see for yourself how cool Greg's flashing LED brake light turned out. I really like the pattern the LED's make on the tail light lens. If you have any pictures or video of a project you have made with the help of Pete's blog, send me an email, I'd like to see!

Betelgeuse Brake Light flasher by Lakeside Electronics, LLC

2012-07-25T08:43:00.002-04:00

It's been a couple months since I have posted anything and that's because I've been hard at work developing a product and starting a company called Lakeside Electronics, LLC. The first product available thru Lakeside Electronics is a brake light flasher to add conspicuity to motorcycles primarily, but also cars, trucks, trailers or even custom vehicles. Actually, Betelgeuse - A Programmable LED Brake Lamp is an LED brake light using 4 Cree X-Lamp LED's with an integrated flash pattern controller.

Check out the video below to see some of the different flash or strobe patterns Betelgeuse ( pronounced BeetleJuice or Betel Juice ) can display. Betelgeuse can even modulate the LED light in a way to look like old school filament bulbs. If you are interested in purchasing Betelgeuse you can head over to the product page at LakesideElectronics.net and hit "add to cart".

Betelgeuse is really cool because it requires no wiring modifications, you just twist the bulb in and you are done. It is fully configurable by using only your brake lever for changing and storing the flash pattern. It also has a recording feature where you can record your own flash or strobe pattern by recording your brakes. The recording time is fixed at 10 seconds which is plenty of time to tap a brake light message in Morse Code. Of course, Betelgeuse can also act as a traditional LED brake light with no flashing too.

If you are interested in the full details you can download the Betelgeuse owners manual from the downloads page to see how capable this modulating brake light really is.

Currently Betelgeuse comes in type 1157 dual filament type bases. Of course, dual filament bulbs fit is several bases in addition to the 1157. There are a couple versions of Betelgeuse brake light strobes in the works, so if you are interested keep checking back to see what's new. I'm really excited about Betelgeuse - A Programmable LED Brake Lamp and I hope you are too.

LED Stroboscope from a Clapper Lamp Prototype

2012-05-27T13:19:00.004-04:00

A little while ago a writer for Popular Science magazine approached me asking if I would be interested in collaborating with them write a " How To " article based on my Clever Clapper post the other month. Well, of course I would, that sounds awesome! And so, I made another Clapper lamp, this time leaving out the laser activated moon lamp so as to better fit the magazine space.

Clapper Demo

Party Mode Demo

Fast forward a few months and you can find in the June 2012 issue, the " Diy Clapper " article on page 80. You can see an online version of the article and links to software etc on the Popular Science page here.

All in all, it was a pretty cool experience, but I am left with another clapper lamp now. And worse, dueling clapper lamps that have no mechanism by which to synchronize themselves. Two claps may or may not turn on both the new clapper lamp and original Clever Clapper leaving me with flip flopping lights until I have to resort to manual control of one or the other lamp.

The non-necessity of having multiple clap activated lamps in my house prompted me to make an LED Stroboscope with the latest lamp - utilizing as much of the hardware as possible. I only added a potentiometer to set the strobe frequency.

I would not design a stroboscope with this hardware from scratch, but it is a good reuse of the lamp and circuit that would otherwise sit idle. For instance, a fairly big drawback is the 8-bit timer in the ATTiny85. The frequency step changes are quite noticeable and I would prefer a 16-bit timer like the ATMega328 has.

And of course with those extra uC pins I could add a display to show the frequency rather than relying on an oscilloscope for measuring the output frequency. Having said that however, with a lack of crystal on the ATTiny85, using the internal RC oscillator instead, it is probably better to measure the frequency externally rather than an internally calculated frequency display.

You can see the hardware changes from the Clapper lamp outlined in the schematic below. I disconnected a few connections and added a potentiometer, that's about it.

The software for the stroboscope can be downloaded here. It isn't the prettiest of code as, but it should suffice until I can build another stroboscope with a more concentrated effort.

To operate the stroboscope you just turn it on and the lamp is strobing somewhere between ~4 Hz and ~31.3 kHz. The maximum flash rate is high enough so as not to be noticed. So you can use it as a reading lamp. Pressing the tactile switch shuffles thru a loop, changing the timer presets thus decreasing the flash rate by 2 times, each press until it loops back to the beginning. Find your range with the tact switch then turn the potentiometer to set the exact frequency required to stop motion.

In the video below, there are on screen comments noting the points where the strobe frequency is a multiple of the fan speed. It is advantageous to use a mark on symmetrical parts to determine when the strobe frequency is a multiple of the part frequency or spot on. I marked this fan blade with a sharpie so I know that if the rotational motion appears stopped and I see two arrows ( sharpie marks ) then the strobe frequency is 2x the fan speed. It should follow that one sharpie mark showing means the strobe is 1x the fan speed. This is the basic principle of stroboscopes, but for a more in depth look have a look at this wikipedia entry.

I am pretty pleased with the results and knowing the limitations of this stroboscope I can still see it being useful to me. Of course I look forward to making a more full featured model with improved timer hardware etc, but for now I can inspect all kinds of rotating or oscillating mechanical bits in pseudo slow motion. I can also measure the speed of unknown objects easily as well as prototype some zoetropes or similar.

As an aside, have a look at this scope my Mother bought me out of the blue the other day - just in time to use it for this project too! How cool is that?

Tenty LED Brake Lights

2012-04-15T21:39:00.000-04:00

UPDATE:
This project was so overwhelmingly well received that it has spawned a commercial interest. The version available for purchase varies somewhat in it's flash patterns and also in the ability to record and play back your own flash patterns. If you would like to check it out take a look at Betelgeuse - A Programmable LED Brake Lamp at my new company Lakeside Electronics, LLC.

I Purchased a motorcycle about two weeks ago. Interestingly, whenever I tell someone this news, they immediately proceed to tell me the most gruesome injuries and stomach turning plights that they or someone they know, has fallen victim to while motorcycling. In some cases, these raconteur's briefly pause to look over their shoulder, presumably scanning for small children or otherwise offendable ears, before delivering the goriest details.

One commonality in these stories, aside from the macabre and arguably poor timing involved in telling them to me is that many accidents come down to a lack of visibility of motorcycles and their riders. Less than Argus-eyed motorists often pull out into the path of a motorcycle and with insufficient time for evasive action, that quickly an accident has occurred. Other times, drivers may focus on the car ahead of the motorcycle and in the event of stopping at a red light or similar, fail to leave enough room for the motorcycle, unfortunately rear ending him or her.

In the photo below, you can see that I am in one piece and the bike is also. Let's see what we can do to help keep things that way.

To partially combat the lack of visibility I decided to make a replacement brake light for my bike; one that would strobe briefly when I applied the brakes then stay solid on. I got this idea when I noticed a similar strobing effect to the brake lights on an ambulance that I was following near to, but not immediately behind. Those lights really got me to notice the ambulance which I had largely ignored up until that point.

I would also want a way to be able to disable the brief flash before the brake light stays solid on. This could be useful if the flash was ever to cause a safety hazard to other drivers or if I am ever stopped by the police for having this system I can easily disable the strobe part and still have a functioning brake light; I do not want to be stranded. I wrote the software so that if you turn the key on while you have the brakes applied, the flash is disabled. You must turn the key off, then back on, without the brake applied to restore the flash functionality.

Here is a video of the prototype Tenty LED Brake Light installed and operating. In the video, I demonstrate the flashing brake light 3 times and then key off. Then I disable the strobing part by turning the key on while holding the brake on, demonstrate that several times and key off again. Finally I re-enable the strobing functionality by key on with the brake off. For the purposes of the video, I lengthened the duration of the flash on and off times. This is so the camera can better capture the flashes.

In order to keep this system reversible should I ever have the need to put it back to stock, here is how I mounted the circuit board inside the tail light lens. I bought some replacement bulbs at a local auto parts store, broke out the glass and desoldered the filament. I replaced the filament by soldering wires to the tail light power, brake light power and ground. I ran a file over the solder blobs just enough to level them out so they would make good contact with the socket. I then filled the bayonet base with epoxy and inserted an 8-32 stainless steel screw into the base being careful not to touch the screw to any metal, accidentally making the screw a conductor. Below are a few pictures of this process.

After installing the modified bayonet screw mounts I threaded two nuts on each and jammed them together. This is what the back of the circuit board will rest on. You can see several pictures of the final assembly below.

Circuit:

The circuit is basically a large array of really bright red LED's ( Light Engine ) and an ATTiny85 microcontroller to tell the LED light engine how to behave. There are also two high brightness LED's that shine downward onto the license plate. They are solid on all the time as required by the Michigan vehicle code. The red LED's, made by Optek have a 100 degree viewing angle and output 8000 mlm each - there are 16 of them. The brake light switch delivers it's ~12 V signal translated thru an 2n3904 transistor to pull a microcontroller pin low. I usually use 14.4 V when doing calculations for operating voltage on 12V systems like this. Total current draw with all LED's at maximum brightness is less than 500 mA. I ordered the logic level mosfet IRLU3410PBF from mouser.com also, which is used for the PWM control of the light engine. Below you will find a screen cap pic of the schematic.

Software

There are two modes of operation to this brake light - flashing and non flashing. The non flashing brake light is activated by turning the key on while holding the brake and behaves just like a stock brake light would. Flashing mode is enabled by default so key on with brake off and you are good to go. In this mode, the LED light engine strobes briefly upon initial application of the brake then is a steady on light. I set the period of the flashes to be higher for the videos so the camera could pick them up, you can see in the code below that the flash period is twice as fast in the operational version of the software. Feel free to use the code as you see fit.

/*
Program Description: 

This program controls an LED light engine used as a brake light on a motorcycle.
When the brakes are applied the tail light flashes several times off then on before
being a steady on brake light.

The program also has a feature to disable the flashing brake light and the brake light will
behave like a standard lamp ie no flashing.  This mode is enabled ( flash mode disabled )
by turning the motorcycles key on while holding the brake on.  The state is reset after a power 
cycle.

Legal Note:  I read the entire vehicle code for my state.  It does not address brake light flashers, but
does prohibit " rotating, oscillating or flashing red lights ".  I believe a brake light flasher
differs from " rotating, oscillating and flashing " lights in the implied duration of operation.  
My state did not respond to emails I sent requesting clarification.  
Basically, modify your vehicle at your own risk.

Change Log
2012.4.21 - added 1 mS debounce to brake switch in main loop - Pete


A circuit description and other details can be found at http://petemills.blogspot.com

Filename: led_brakelight_main.c
Author: Pete Mills
petemills.blogspot.com
2012.4.15

Int. RC Osc. 8 MHz; Start-up time PWRDWN/RESET: 6 CK/14 CK + 64 ms

*/



//********** Includes **********

#include <avr/io.h>     
#include <util/delay.h>   



//********** Definitions **********

// Output to LED Light Engine

#define LED   PB0  
#define LED_PORT PORTB
#define LED_DDR  DDRB


// Input for Brake Switch

#define BRAKE_SWITCH  PINB4  // bit is clear when brake switch is pressed
#define BRAKE_SWITCH_PORT PINB
#define BRAKE_SWITCH_DDR DDRB



// PWM Preset Values

#define TAIL_LIGHT_PWM  25
#define BRAKE_LIGHT_PWM  255



//********** Function Prototypes **********

void setup( void );
void brake_alert( uint8_t number_of_flashes );



//********** Global Variables **********

uint8_t disable_flash = 0; // if 1, the flashing part of the brake light will be disabled


int main(void)
{


setup();

_delay_ms( 5 );



// if the brake light is held on during boot up, disable the flashing
// flashing can only be disabled during boot up ( key on ) and is reset after power down ( key off )
// this could be useful if you suddenly learn your flashing light is causing a problem for other motorists 
// or citizens employed to monitor the adherence to legislation and cite violations for deviation from such 


if ( bit_is_clear( BRAKE_SWITCH_PORT, BRAKE_SWITCH ) )
{
 disable_flash = 1; 
}



 while(1)
 { 
  
  
  if ( bit_is_clear( BRAKE_SWITCH_PORT, BRAKE_SWITCH ) )  // if the brakes are applied
  {

   _delay_ms( 1 ); // filter time aka debounce

   if ( bit_is_clear( BRAKE_SWITCH_PORT, BRAKE_SWITCH ) )  // if the brakes are actually applied
   {  

   // if we are allowed to flash, do
   
   if( disable_flash == 0 ) 
   {
    brake_alert( 5 );
   }
  

   // if the brakes are still applied, hold the LED light engine to a brighter output
   // until you release the brakes
   
   while( bit_is_clear( BRAKE_SWITCH_PORT, BRAKE_SWITCH ) )
   {
    OCR0A = BRAKE_LIGHT_PWM;
   }
   
   _delay_ms( 100 ); // debounce the brake switch release ( break )
   
   }   

  }
  
  OCR0A = TAIL_LIGHT_PWM;  // restore the tail light on
  
  
  
  /*
  // demo mode
  for( ;; )
  {
  brake_alert(6);
  OCR0A = BRAKE_LIGHT_PWM;
  _delay_ms(2000);
  OCR0A = TAIL_LIGHT_PWM;
  _delay_ms(4000);
  }
  */
   
 }
}




//********** Functions **********

void setup(void)
{



 //********* Port Config *********

 LED_DDR |= ( 1 << LED);   // set PB0 to "1" for output 
 LED_PORT &= ~( 1 << LED );   // turn the led light engine off

 BRAKE_SWITCH_DDR &= ~( 1 << BRAKE_SWITCH );   // set BRAKE_SWITCH pin to 0 for input
 BRAKE_SWITCH_PORT |= ( 1 << BRAKE_SWITCH );   // write a 1 to BRAKE_SWITCH to enable the internal pullup



 //********** PWM Config *********
 
 TCCR0A |= ( ( 1 << COM0A1 ) | ( 1 << WGM01 ) | ( 1 << WGM00 ) ); // non inverting fast pwm
 TCCR0B |= ( 1 << CS00 ); // start the timer
 
 
}




void brake_alert( uint8_t number_of_flashes )
{
 // here we create a visual alert that the brakes have been applied
 // pass this function the number of flashes desired ( off then on = 1 )
 
 //uint8_t delay_between_flashes = 50; // for video demonstration purposes ( video aliasing issues ) 
 uint8_t delay_between_flashes = 25; // every day use
 uint8_t alert_pwm_min = 2;   // minimum and max values to flash between during the alert
 uint8_t alert_pwm_max = 255;
 
 
 for( int i = 0; i < number_of_flashes; i++ )
 {
  OCR0A = alert_pwm_min;
  _delay_ms( delay_between_flashes );
  OCR0A = alert_pwm_max;
  _delay_ms( delay_between_flashes );
 }

}

Legal Note:

I'm not too sure what to say about the legality of this project. I read the entire vehicle code for my state. There was no reference to brake light flashers for cars or motorcycles. The vehicle code for Michigan does prohibit " rotating, oscillating or flashing lights " on non-emergency vehicles, however I believe my brake light does not qualify as the clear intent in the vehicle code was " rotating, oscillating or flashing " lights that continue to do so for an extended period of time as emergency or police vehicles do. Really, my device is no different than tapping your brake pedal several times before stopping your motorcycle. In the end, I did send an email to the state of Michigan requesting clarification. At the time of this writing there has been no response. I think the bottom line is, don't modify your vehicle unless you are willing to accept full responsibility for any outcome.

Here are a couple pictures of the build process. The abstract looking pictures are of the LED light engine shining thru my desk magnifier onto the ceiling.

ATTiny Candle

2012-02-05T10:17:00.000-05:00

The ATTiny Candle is an LED candle. It uses a high brightness LED and some software to mimic the look of a traditional candle without the dangers associated with an open flame. I imagine they could be useful as movie props where you cannot afford to have a candle go out during a take or in your home in places not suitable for traditional candles such as in a wall niche or alcove.

I have wanted to make an LED candle for some time now, so when I was approached by a work colleague about making one, I was provided the yeast to give it a go. I figured the hardest part of this project would be making the flicker look realistic, so I decided to let nature do that part for me. I made this candle with a Light Detecting Resistor ( LDR ) and a fixed resistor acting as a voltage divider. This is fed to one of the ATTiny85's ADC inputs and sampled at discrete time intervals. At this time, the sample rate is 100mS. These 8-bit light level values are then stored to EEPROM so that the candle can recall the flicker pattern to play back on the LED that is connected to a PWM channel after being turned off. You only need to program the pattern once, but you can program it over and over again with just the push of a button.

What I have really created here is a datalogger for light levels. Albeit, a datalogger with fairly small storage space of 500 bytes for the ATTiny85. Never the less, 500 bytes @ 100mS sample rate gives me a loop of ~50 Seconds. This is sufficiently long to not see a pattern repeating in the flicker pattern. I guess there is a transformation that occurs when you jam the whole thing into the middle of a candle it becomes an electronic LED Candle instead. Below is a picture of the aforementioned transformation process.

I did not mention yet, that I used a perfectly functional LED candle as the housing for my ATTiny Candle. It was about 50c from the thrift store, so it is a cheap enclosure. I also scavenged the high brightness LED from the original circuit. Not knowing the specs on the led I set out to measure the forward voltage. I lit the LED with a high value resistor in series. In the picture below you can see I am using an LED tester I made that has probably an R860 or 1k0 resistor in it. The LED plugs into some female header sockets. Measuring the voltage across the LED legs shows I have a forward voltage of 2.01v. I will assume 20mA max and select my series resistor based on 3, 1.5v ( nominal ), AA batteries. So, ( ( 3*1.5v ) - 2.01Vf ) / 0.02mA = R124.5. I guess the closest value I had on had was an R220 because that is what I used so the LED current is now ~11mA.

Here is a picture of the schematic and one of the assembled circuit about to be installed ( hot glued ) into the inside of a candle.

//Software &c

Here is a listing of the current working code. I have several improvements I would like to add in the future, but I will outline them later.

/*
Program Description: This program reads a light detecting resistor thru an internal ADC and stores the value, 
after scaling it, to eeprom.  This ADC value is sent to a PWM channel with attached led.  This is essentially a data logger
for light and replay by LED.  If, if you aim the LDR at a flickering candle during its recording phase, you have a flickering 
led candle.  

A circuit description and other details can be found at http://petemills.blogspot.com

Filename: ATTiny_Candle_v1.0.c
Author: Pete Mills

Int. RC Osc. 8 MHz; Start-up time PWRDWN/RESET: 6 CK/14 CK + 64 ms

*/



//********** Includes **********

#include <avr/io.h>     
#include <util/delay.h>   
#include <avr/eeprom.h>




//********** Definitions **********

// LED for flame simulation

#define LED   PB0  
#define LED_PORT PORTB
#define LED_DDR  DDRB



// Light Detecting Resistor for recording a live flame

#define LDR   PINB3 
#define LDR_PORT PINB
#define LDR_DDR  DDRB



// Tactile Switch Input

#define SW1   PINB4
#define SW1_PORT PINB
#define SW1_DDR  DDRB


#define ARRAY_SIZE 500  // size of the flicker array
#define SAMPLE_RATE 100  // ms delay for collecting and reproducing the flicker



//********** Function Prototypes **********

void setup(void);
void toggle_led(void);
void program_flicker(void);
void led_alert(void);
void eeprom_save_array(void);
void eeprom_read_array(void);
void scale_array(void);
uint8_t get_adc(void);
uint8_t scale( uint8_t input, uint8_t inp_low, uint8_t inp_hi, uint8_t outp_low, uint8_t outp_hi);
uint8_t is_input_low(char port, char channel, uint8_t debounce_time, int input_block);




//********** Global Variables **********

uint8_t flicker_array[ ARRAY_SIZE ] = { 0 };
uint8_t EEMEM ee_flicker_array[ ARRAY_SIZE ] = { 0 };


int main(void)
{

uint16_t replay = 0;

setup();

eeprom_read_array();



 while(1)
 { 
 
  
  
  
  if( is_input_low( SW1_PORT, SW1, 25, 250 ) )
  {
   
   // program the flicker
   // after entering and upon completion, a predetermined flash pattern will occur as described in led_alert()  
   // aim the ldr at a flickering candle or any other light source ( like a laser ) you want to record during this time
   // and upon completion the values are stored to eeprom.  They are played back immediately as well 
   // as being recalled from eeprom upon first start up
   
   led_alert();
   program_flicker();
   scale_array();
   eeprom_save_array();
   led_alert();
  }
  
  
  
  // replay the recorded flicker pattern 
  
  OCR0A = flicker_array[ replay ];
  ++replay;
  
  if( replay >= ( ARRAY_SIZE - 13 ) ) // if the end of the stored array has been reached
  { 
   replay = 0;          // start again from the beginning
   //led_alert();
  }
  
  _delay_ms( SAMPLE_RATE );
  _delay_ms( 3 );    // ADC Conversion time
   
 }
}




//********** Functions **********

void setup(void)
{



 //********* Port Config *********

 LED_DDR |= ( 1 << LED);   // set PB0 to "1" for output 
 LED_PORT &= ~( 1 << LED );   // turn the led off

 LDR_DDR &= ~( 1 << LDR );   // set LDR pin to 0 for input
 LDR_PORT |= ( 1 << LDR );   // write 1 to enable internal pullup

 SW1_DDR &= ~( 1 << SW1 );   // set sw1 pin to 0 for input
 SW1_PORT |= ( 1 << SW1 );   // write a 1 to sw1 to enable the internal pullup



 //********** PWM Config *********
 
 TCCR0A |= ( ( 1 << COM0A1 ) | ( 1 << WGM01 ) | ( 1 << WGM00 ) ); // non inverting fast pwm
 TCCR0B |= ( 1 << CS00 ); // start the timer
 
 
 
 //********** ADC Config **********
 
 ADMUX |= ( ( 1 << ADLAR ) | ( 1 << MUX1 ) | ( 1 << MUX0 ) );  // left adjust and select ADC3
 ADCSRA |= ( ( 1 << ADEN ) | ( 1 << ADPS2 ) | ( 1 << ADPS1 ) ); // ADC enable and clock divide 8MHz by 64 for 125khz sample rate
 DIDR0 |= ( 1 << ADC3D ); // disable digital input on analog input channel to conserve power

}




void toggle_led()
{
    LED_PORT ^= ( 1 << LED );
}




uint8_t is_input_low( char port, char channel, uint8_t debounce_time, int input_block )
{

/*
This function is for debouncing a switch input
Debounce time is a blocking interval to wait until the input is tested again.
If the input tests low again, a delay equal to input_block is executed and the function returns ( 1 )
*/
        
 if ( bit_is_clear( port, channel ) )
 {
  _delay_ms( debounce_time );
   
   if ( bit_is_clear( port, channel ) ) 
   {
    _delay_ms( input_block );
    return 1;
   }
 
 }

 return 0;
}




uint8_t get_adc()
{
 ADCSRA |= ( 1 << ADSC );   // start the ADC Conversion
 
 while( ADCSRA & ( 1 << ADSC ));  // wait for the conversion to be complete
 
 return ~ADCH; // return the inverted 8-bit left adjusted adc val

}




void program_flicker()
{ 
 // build the flicker array
 
 for( int i = 0; i < ARRAY_SIZE; i++ )
 {
  flicker_array[ i ] = get_adc();  
  _delay_ms( SAMPLE_RATE );
 }

}




void led_alert()
{
 // this is a function to create a visual alert that an event has occured within the program
 // it toggles the led 10 times.
 
 for( int i = 0; i < 10; i++ )
 {
  OCR0A = 0;
  _delay_ms( 40 );
  OCR0A = 255;
  _delay_ms( 40 );
 }

}




void eeprom_save_array()
{ 
 for( int i = 0; i < ARRAY_SIZE; i++ )
 {
  eeprom_write_byte( &ee_flicker_array[ i ], flicker_array[ i ] );
  
 }
}




void eeprom_read_array()
{
 for( int i = 0; i < ARRAY_SIZE; i++ )
 {
  flicker_array[ i ] = eeprom_read_byte( &ee_flicker_array[ i ] );
  
 }
}




uint8_t scale( uint8_t input, uint8_t inp_low, uint8_t inp_hi, uint8_t outp_low, uint8_t outp_hi)
{
return ( ( ( input - inp_low ) * ( outp_hi - outp_low ) ) / ( ( inp_hi - inp_low ) + outp_low ) );
}




void scale_array()
{
 uint8_t arr_min = 255;
 uint8_t arr_max = 0;
 uint8_t out_low = 20;
 uint8_t out_high = 255;
 
 
 
 // find the min and max values
 
 for( int i = 0; i < ARRAY_SIZE; i++ )
 {
  if( flicker_array[ i ] < arr_min )
   arr_min = flicker_array[ i ];
   
  if( flicker_array[ i ] > arr_max )
   arr_max = flicker_array[ i ];
 }
 
 
 
 // now that we know the range, scale it
 
 for( int i = 0; i < ARRAY_SIZE; i++ )
 {
  flicker_array[ i ] = scale( flicker_array[ i ], arr_min, arr_max, out_low, out_high );
 }
 
}

After I programmed a flickering candle to the EEPROM using the above code I read back the data. Below is 500 bytes of candle flicker data just in case you don't care to have a reprogrammable flicker you could use this static one.

:10000000777B7D7B78BA95535E3E3E4352353E7595
:100010004B657B5263586B5562777287858C5D7A2E
:10002000535D5062556F6758784E55956B6D7D7373
:100030007D5B6B686A6A606B7777987A87605B6BC9
:10004000534A5368453B65679C6067537375638A81
:100050007F8388806358586B7A787B838A878A8508
:1000600083888A8A8A8A8A8C8A8A8A8A8A88837F0B
:100070007D7B7A78777570707270704D416D6860B5
:1000800035353D3B4145525E41535D60656A5048A0
:100090004B4E3535313333363B40504E525D605315
:1000A000564B352D2E2E353838393B383158406077
:1000B0004D505A5D434053585A554E31312B2E33D3
:1000C0003136353638393938404A413B506240364E
:1000D000292D455E5D523E333B433545383531333E
:1000E00036363936383B4136363039332B29335A98
:1000F0006356413D5052556065553B302E303B4E66
:10010000362E2B3B393D4A503D45584E4B4E4A45C5
:10011000584B555D5B56585E60775E385A52464B79
:10012000504A4A354E412E363638524B463B3340C4
:100130004E605A504D434A504B48403D4046525BFA
:100140006263635B52465B43554526353B5B434DDB
:100150004056585A5D50464545413B437287908A08
:100160008F979D9573656B4D464555554156555531
:10017000565A5A5B5E56625565585A62686D6D6B89
:10018000686A6F656D316F55485055675A41555EC5
:100190006065686863606A60676A7F838C8788923D
:1001A0008D8F888C8C85826A4E35231119433B4193
:1001B000674A4A3B2E3045414A5848705B6D72622F
:1001C0007567565A5E554D77532D36415D55404003
:1001D0004040403E415E82928888909488857B634F
:1001E000555356555053550334013A7EFF01603E36
:1001F0003E28018EFFFFFFFFFFFFFFFFFFFFFFFF16
:00000001FF

Here is a video of a LDR programmed candle flicker. I was blowing gently on the candle flame during recording so that it would be a lively flicker for the video. It reminds me of a candle on the porch when a storm is coming in. Of course, it can be reprogrammed with a more subtle flame, the light from a bonfire or fire place, a laser pointer or even your hand shading light from the LDR. You could take a walk thru the woods and record the sunlight shining thru and shadows coming from the treetops. I have found the best results when programming the ATTiny Candle in a darkened room.

The list of improvements...

A) I would get the lower power version of the ATTiny85 to allow operation from 2 AA batteries. I only had ATTiny85-20PU in stock so I had to use 3 batteries. The black box external to the candle is the battery box. Unsatisfactory, really.

B) Once the batteries are tucked away and the switch is no longer accessible it may be a good idea to put the candle to sleep instead of switching it off. It could, for example, turn itself off after an hour or two of operation too. Then it could wake up with an external interrupt. And what would interrupt it? Improvement C of course.

C) A "blow" detector to be able to blow "out" and back "on", the candle. I did some quick experimentation with a piezo to detect a "blow" ( I guess ), although it worked, I abandoned the idea, saving it for later iterations. I couldn't find a location for the large piezo speakers I have, so I will have to order some smaller ones.

D) If you have any ideas please leave a comment!

Here are a couple more photos. Let me know if you have any success building an ATTiny Candle yourself.

The Clever Clapper

2012-01-14T22:49:00.000-05:00

The other day when I was at the reuse center I came across a few ikea lamps. I picked up two low voltage spot lights for $2 total. I think they came from this lamp. I also bought a moon lamp for $0.86 and I am still not sure why they charged such an odd amount for it. I wasn't too sure about the moon lamp, but I knew right away what I would do with the spot lights. It wasn't even 12 hours prior that I was trying to sketch up an idea on my slate chalkboard in low light conditions and thought I needed some task lighting. That distraction was what spawned this project.

Surely these lights would do great on their own with just an on/off toggle switch, but where is the fun in that? So, I decided to make a clapper circuit that turned out to be something a little more too.

A "Clapper" is a device that will turn on or off an AC appliance that is plugged into it, such as a lamp or fan when it "hears" you clap twice in approximate succession. They were originally sold in the mid eighties and it appears you can still buy them today.

In my version of the clapper if you clap twice within one second, the circuit toggles the lamp output. On becomes off and vice versa. If you clap three times within one second, the lamps begin dimming up and down via PWM until a fourth clap is detected or a one minute timeout occurs, whichever comes first. The brightness value is then stored and restored for subsequent toggling of the lights on/off with the two clap event. I also added a relay output to turn on and off the moon lamp. To trigger this relay, you shine a laser beam at the circuit to toggle it. Laser beams begets moon beams. It's science.

Here is a video of the Clever Clapper in action.

In case you are confused by the title of this post being the Clever Clapper and the text on the chalk board that says The Dandy Dapper Clapper you should know that the Clever Clapper is the hardware that a Dandy Dapper Clapper uses to clap his or her way to optimal lighting conditions.

These spot lamps didn't come with anything other than the lamp and holder. I needed a way to hold the holder so I banged a couple of nails into a some poplar wood to attach the lamp holder to. Ok, so I didn't "bang" these framing nails into the 1" x 2" bit of poplar wood so much as I drilled a hole slightly smaller than the O.D. of the nail and pressed them in, but you get the idea. This is not a finished installation; just the prototyping stage.

Here is a pic of the lamp, lamp holder, lamp holder holder and the lamp holder holder holder ( aka wall ).

Since we are talking about mechanical stuff, below is a picture of how the circuit and moon lamp are mounted to a piece of red oak. The wood board was drilled and tapped to accept aluminum standoffs to screw the circuit board and TIP120 heatsinks to.

Here are a couple of pictures showing the inside of the moon lamp. I added this black box with relay inside to control the hot AC line of this lamp with a microcontroller.

You can download a .rar of the ATTiny2313 code and Clever Clapper circuit schematic here.

There isn't much to say about the software except that there may be some "legacy" code in it still. That is, variables and the like that I didn't delete when changing things around or removing functionality so the program would fit into the available program space.

Below is a picture of the schematic. Starting at the top left you can see an electret microphone and it's filtered power supply. This is fed into one half of an LM358 Op-amp setup for 100x amplification. The 100k0 potentiometer is used for clap detection sensitivity adjustment. There is a connection to PD3 here that is no longer used, but more on that later. Then, the signal, or more accurately, part of the signal passes thru a low pass filter and on to the other half of the LM358 setup as a comparator. The output of this comparator stage is fed to the ATTiny2313. Otherwise the circuit is pretty straight forward, standard 7805 power supply and uC accoutrements, TIP120 darlington transistor with pulldown resistors. Oh, and don't forget that 1n4004 flywheel diode across the relay coil or you will be replacing your uC in very short order.

Here is a close up of the circuit. You can see the electret mic in the lower middle. There are two phototransistors on the board but only one is connected. They are the clear things with one at the center top of the ATTiny2313. There is also a red tactile switch who's input to the microcontroller is interpreted as two hand claps. This is used in the event you want to be quiet and still toggle the lights on and off.

When I first started this project I knew that I wanted to detect hand claps. As a human, I am quite good at this but, I had no idea how to describe a hand clap to a microcontroller. So, to "see" as a digital device would, I opened Audacity and started clapping my hands. Below is a picture of the spectrum analysis. To help prevent false triggers, it appears I can easily block non-clapping frequencies above ~5khz. This significantly improved the reliability of the circuit.

As I alluded to earlier I was not able to implement all of the features I wanted in my clapper. This is because I ran out of program memory. The last build used 100.0% of the available space. Of course I could have re-written the code trying to optimize for space or more likely I will just use a different uC in subsequent hardware iterations, should I decide the current implementation is prosaic. I feel code and hardware optimizations are a worthy subject of focus, but too, sometimes you just want to get the job done.

Here is a video of one feature that didn't make the cut due to the lack of program memory space. This mode would have been activated by a succession of four claps. In this mode, the raw speaker input ( pre-lowpass filter ) is fed to the microcontroller and modulates the PWM output to the lamps. The light looks like it is "talking" to you. It is a little hard to see in the video as I think the automatic white balance function of the video camera takes some of the resolution away. I was sad to see this feature go.

Over all I am quite pleased with the Clever Clapper. It is a lot of fun walking into a room and command-clapping lights to turn on - to your desired brightness value no less. I have yet to decide if I want to remake the hardware to allow for more features. I may, as one feature I wanted was clap programmable clap codes for instantly setting different lighting moods.

// clap off

Capricious Clock

2011-12-11T15:43:00.004-05:00

A couple of months ago I took a break from working on a precision pendulum clock project to build this. I call it a capricious clock for reasons that will be obvious after watching the video below. It ticks and tocks in an unnerving and aperiodic or spasmodic manner that anthropomorphically demands your attention. Even as the author of the software, I find myself lured in, staring the capricious clock down, face to face, anticipating and wondering when and sometimes if, the next tick will occur. Mercurial, you say? Precisely, but alliteration won out and "Capricious Clock" it is.

The most marvelous part of all of this, of course, is that the clock keeps accurate time over the long term. Neglecting inaccuracies inherent to quartz clocks, this clock could conceivably be off by no more than 8 seconds at any point in time. However, at no point in time do you ever feel the displayed time is something to be believed. I would like to place this clock in a public area to gauge peoples reactions. For now, it is on a show and tell basis, hanging on a wall at home.

Here is a video of the Capricious Clock running next to a regular AC wall clock. In the video, I fast forward by 500% at 1:12 until near the very end. This video is illustrative of the erratic ticking of the capricious clock on the right next to a smooth AC clock motor sweeping second hand.

The idea for a mind-melting ticking machine came from the author Terry Pratchett. There is "Lord Vetinari's Clock" in the series Discworld. I'm not exactly sure how, as it seems everyone around me is familiar with Discworld , but I am just finding out about it now. Actually, it was a similar clock that someone else built that got me thinking about how I would go about making something like this for myself.

That is the what and why, now on to the how...

In the pictures below you can see how the quartz clock movement was modified to intercept the 1pps signal and output my own clock "motor" drive pulse. I cut the traces going to and from the "black blob" IC on the circuit board for the 1pps signal and motor drive pulse. These were then soldered to fine gauge enameled wire and brought out to a strip PCB for later access.

In the picture below you can see how the quartz clock movement works. The black cylinder on the end of the white plastic gear is a magnet. It's poles are aligned perpendicular to its axis of rotation. When the movement is assembled, the copper wire electromagnet is pulsed once per second, alternating polarity and consequently magnetic poles to drive the movement. The relative location of the gear magnet and electromagnet ensure that the clock moves in the clockwise direction usually. It is possible with different electromagnet pulse durations to sometimes generate an anticlockwise tick. Nothing reliable enough for an open loop system like this though.

Below is the quartz movement with enameled wire soldered to the cut PCB traces. You may notice this is a different quartz movement than the one finally installed in the clock. I had to modify a new movement after accidentally applying 5v to one of the black blob IC traces and consequently rendered it useless.

Here you can see the fine enameled wire brought out to some blank PCB for more robust attachment of wires that will be controlling the clock and receiving the 1 pps signal.

At this point you could jumper the correct traces back together and the quartz motor would function as originally intended, but next a microcontroller comes in to modify the 1 pps to something a little less phlegmatic.

Here is the schematic for what we have done so far to the quartz movement and what is to come by adding a uC.

I mention in at least 4 places ( here included ) that after programming the chip you have to set the RSTDISBL fuse if you want to use PB5 as an IO pin. Once you do this, you cannot use ISP programming and instead have to do high voltage programming to bring the reset line up to 12v. For this reason, I have yet to test my code using PB5 as the intended "Mute" switch. I want to use it to toggle on or off the ability for the uC to make a tick-tock sound with the piezo. Until I am happy with the code, and I think I am nearly, I don't want to commit to the RSTDISBL fuse programming. I guess this capricious clock is not currently mutable?... 0_0

One way around the RSTDISBL / PB5 issue I describe is to use a boot loader on the ATtiny. I may do this because I don't like the idea of not being able to easily change the firmware at a later date and I have never used a boot loader on an ATtiny before and it may be fun.

A couple of other ideas I had for erratic ticking I had were to tick faster from 0s-30s and slower from 30s-60s as if the clock was operating in a larger gravitational field than its surroundings and the motor just barely keeps up. Or, the same erratic ticking over a longer time though so that it drifts +/- 5 minutes an hour or so. I think this will eventually catch someones attention, but it would take longer to notice. For these reasons I think I have just convinced myself to remake this project with an added bootloader on the ATtiny85.

Here are a couple of pictures from the inside of the clock. This clock made it really easy to shoehorn the additional electronics inside.

// software

The code keeps track of the 1pps pulses coming from the quartz clock movement, it delays for a random period of time then moves the second hand. If the "Real Time" elapsed is greater than the displayed time the program will delay anywhere from 1-0.125s to catch up to the "Real Time". If the display time is faster, the program will select a random time from 1-8s to slow down so that "Real Time" can catch up.

Rather than just turning the thing on and letting it run in an endless loop I used external interrupts, nested interrupts and the watchdog timer with power down sleep mode to wake up from a sleep period to update the display.

Using the aforementioned capabilities of the ATtiny85 was necessary for the reliability of counting the 1pps pulse and the ability to conserve battery power - a very important thing to do in battery powered devices. You can see in the calculations below the clock will theoretically run for ~225 days or ~61.6% of a year before needing new batteries. Now, that is theoretical and does not account for sleep current, wake up current and time or battery self discharge. However, in this case, where the ratio of active to sleep current is so great, you can safely ignore those calculations. By entering into power down sleep mode the battery life is extended by nearly 3 months.

Here is the code. As previously stated the switch on PB5 is commented out in the code so it will not work. I did this because I am not done using the ISP and will probably use a bootloader in the end.

/*

Program Title: Capricious Clock
Author: Pete Mills
Date: 2011.12.09
petemills.blogspot.com

Filename: capricious_clock_v1.0_main.c

Int. RC Osc. 8 MHz; Start-up time PWRDWN/RESET: 6 CK/14 CK + 0 ms
ck div by 8 for 1MHz system clock

Set RSTDISBL fuse after programming to allow use of PB5
After setting RSTDISBL you will have to use HV programming to reprogram the AVR - no more ISP

*/

// Includes

#include <avr/io.h>     
#include <util/delay.h>    
#include <avr/interrupt.h>
#include <avr/sleep.h>


// Definitions

#define IO_PORT  PORTB
#define LED   PB0  // LED pin PORTB Pin 4
#define BUZZER   PB1  // piezo output buzzer
#define PPS_IN   PB2  // 1 Hz input signal
#define SEC_MOT_1 PB3  // output to drive seconds motor coil on quartz clock
#define SEC_MOT_2  PB4  // another output to seconds motor coil on quartz clock assy
#define MUTE_SW  PB5  // input switch for muting piezo and ...?


// function prototypes

void setup(void);
void toggle_led(void);
void inc_sec(void);
void tick_tock(void);



// Global Constants


volatile uint32_t rt_sec = 0; // actual time elapsed
volatile uint32_t my_sec = 0; // seconds displayed on the clock
volatile uint8_t  do_tick = 0; // decide to tick or not



int main(void)
{

setup();
sei(); 
set_sleep_mode(SLEEP_MODE_PWR_DOWN);



 while(1)
 { 
  /*
  // turn on or off the ticking sound
  if ( bit_is_clear( PINB, MUTE_SW ) ) 
  {
   ++do_tick;
   
   if( do_tick > 1 )
   {
    do_tick = 0;
   }
  
  }
  */
  
  asm("nop");  // ISR's return to main to execute a minimum of one instruction 
  asm("nop");  // before executing pending interrupts
  
  sleep_mode(); // go back to sleep
  
 }
 
}




// functions

void setup(void)
{

// Port Configuration

 DDRB |= ( ( 1 << SEC_MOT_1 ) | ( 1 << SEC_MOT_2 ) | ( 1 << BUZZER ) | ( 1 << LED ) ) ;  // set PB1::PB4 to "1" for output 
 IO_PORT &= ~( ( 1 << SEC_MOT_1 ) | ( 1 << SEC_MOT_2 ) | ( 1 << BUZZER ) | ( 1 << LED ) ); // set the outputs low

 DDRB &= ~( ( 1 << PPS_IN ) | ( 1 << MUTE_SW ) ); // set PB0 and PB5 to "0" for input
 IO_PORT |= ( 1 << MUTE_SW );      // enable internal pullup on input switch
 

// Interrupt Configuration

 // External Interrupt INT0 ( INT0_vect )
 
 // low level on INT0 causes interrupt
 
 GIMSK |= ( 1 << INT0 ); // enable external interrupt on INT0
 
 
 // Watchdog Timer Interrupt ( WDT_vect )
 
 WDTCR |= ( ( 1 << WDCE ) | ( 1 << WDE ) );
 WDTCR &= ~( 1 << WDE );
 
 WDTCR |= ( 1 << WDIE ); // watchdog timeout interrupt enable
 WDTCR |= ( ( 1 << WDP0 ) | ( 1 << WDP2 ) ); // half second sleep

}


void toggle_led()
{
    IO_PORT ^= (1<<LED);
}



// function to drive the quartz clock motor
void inc_sec()
{

 if( my_sec % 2 == 0 )
 {
  IO_PORT |= ( 1 << SEC_MOT_1 ); 
 }
 else
 {
  IO_PORT |= ( 1 << SEC_MOT_2 ); 
 }
 
 _delay_ms(30); // empirically derived pulse duration
 
 IO_PORT &= ~( ( 1 << SEC_MOT_1 ) | ( 1 << SEC_MOT_2 ) );

}



// making the tick tock escapement sound
void tick_tock()
{

 if( rt_sec % 2 == 0 )
 {
  IO_PORT |= ( 1 << BUZZER );
  _delay_us(200);
  IO_PORT &= ~( 1 << BUZZER ); 
 }
 else
 {
  IO_PORT |= ( 1 << BUZZER );
  _delay_ms(1);
  IO_PORT &= ~( 1 << BUZZER );  
 }
 
}




// this ISR is called once per second as the quartz clock movement outputs its pps signal 
ISR( INT0_vect )
{
 ++rt_sec;
 
 if( do_tick )
 {
  tick_tock();
  //toggle_led();
 }

 
 while( bit_is_clear( PINB, PPS_IN ) )
 {
  // stay in ISR until input signal is high again to stop multiple triggers
 }

}



// this ISR is called to update the output display
ISR( WDT_vect )
{
 sei(); // allow this interrupt to be interrupted...
 
 uint8_t rand_num = (uint8_t) rand();
 uint8_t case_sel = 0;

 ++my_sec;  // increment displayed time counter
 inc_sec();  // move the second hand
 
 rand_num = (uint8_t) rand();
  
  
  case_sel =  rand_num % 4 ;
  
  if( my_sec > rt_sec )
   case_sel += 3;
  
  
  switch (case_sel)   // set sleep time
  {
   case 0: 
    WDTCR &= ~( ( 1 << WDP3 ) | ( 1 << WDP2 ) ); 
    WDTCR |= ( ( 1 << WDP1 ) | ( 1 << WDP0 ) );     // ~0.125s sleep
   break;
   
   case 1: 
    WDTCR &= ~( ( 1 << WDP3 ) | ( 1 << WDP1 ) | ( 1 << WDP0 ) ); 
    WDTCR |= ( 1 << WDP2 );          // ~0.25s sleep
   break;
   
   case 2: 
    WDTCR &= ~( ( 1 << WDP3 ) | ( 1 << WDP1 ) ); 
    WDTCR |= ( ( 1 << WDP2 ) | ( 1 << WDP0 ) );     // ~0.50s sleep
   break;
   
   case 3: 
    WDTCR &= ~( ( 1 << WDP3 ) | ( 1 << WDP0 ) ); 
    WDTCR |= ( ( 1 << WDP2 ) | ( 1 << WDP1 ) );     // ~1.00s sleep
   break;
   
   case 4: 
    WDTCR &= ~( ( 1 << WDP3 ) ); 
    WDTCR |= ( ( 1 << WDP2 ) | ( 1 << WDP1 ) | ( 1 << WDP0 ) ); // ~2.00s sleep
   break;
   
   case 5: 
    WDTCR &= ~( ( 1 << WDP2 ) | ( 1 << WDP1 ) | ( 1 << WDP0 ) ); 
    WDTCR |= ( 1 << WDP3 );          // ~4.00s sleep
   break;
   
   case 6: 
    WDTCR &= ~( ( 1 << WDP2 ) | ( 1 << WDP1 ) ); 
    WDTCR |= ( ( 1 << WDP3 ) | ( 1 << WDP0 ) );     // ~8.00s sleep
   break;
   
   default: 
    WDTCR &= ~( ( 1 << WDP3 ) | ( 1 << WDP0 ) );      // should never occur
    WDTCR |= ( ( 1 << WDP2 ) | ( 1 << WDP1 ) );     // but set the WDT for 1s if it does
   
  }
  
}

Arcade Push Button Light Switch Redux

2011-09-08T13:48:00.003-04:00

I got a lot of feedback on my post from a couple days ago about making an Arcade Push Button Light Switch. Mostly that this task could be easily accomplished with a single DPDT 110VAC relay. While this true, the original post was really about using what I had on hand at the moment to remake something I saw online.

Never the less, while I was at Grainger this morning picking up supplies for another project I also grabbed a DPDT relay, part no. LY2-AC110/120, to make another version of the arcade button light switch. This is how I would make the switch if I was going to be purchasing parts for it.

Here is a schematic. This sort of design has been around for ages. I guess people used to use relays for all kinds of control applications and called it Relay Logic.

* Update *

A few people have asked for more pictures of what wires go where. Unfortunately, I do not have any photographs that would be useful. I did draw the picture below, though and I know of at least one person that built this switch based on it. If you are unfamiliar with working with 120v household wiring be sure to ask someone who is in the know for some help. Getting a shock from 120vac is unpleasant.

Below is a picture of the microswitches in the arcade pushbuttons. As you can see they are more than capable of switching the voltage and current required for this design.

So, wire it all up, apply some hot glue and drink some coffee.

And then take an action video. I am switching my frequency counter in this video. It is kind of handy anyway as the power switch for the counter is on the back of the unit. I don't always use my frequency counter, but when I do, it's a pain to turn it on. Well, not anymore.

Arcade Pushbutton Light Switch

2011-09-06T20:16:00.006-04:00

UPDATE: If you would like to see different circuit design, have a look at version 2.

I was poking around the internets on Labor day when I came across this. It is a wall switch intended to replace a boring old toggle switch in your arcade room. My single arcade machine does not warrant its own room, but I do like the idea of an arcade button light switch. So, in an effort to get up and do something I made this arcade button switch for switching an extension cord. I have it plugged into the magnifier with fluorescent lamp on my electronics bench.

Since it was a holiday, I wanted to use only parts I had on hand so that I could finish this project the same day. Fortunately, I have a pretty large selection of bits that included arcade buttons. Sadly, I had no triacs, though and settled for a relay instead.

There are quite a few ways that you could make a set/reset flipflop circuit for this purpose. I settled on a 555 timer setup with relay. The flipflop could have just as easily been two NPN transistors, but I felt like reminiscing with the venerable 555 timer.

Download the schematic here if you like...

I very slowly drilled two holes in a cover plate.

Circuit assembly began with the relay I had on hand. I soldered some leads to the normally open contacts on the relay and put heatshrink on the solder joints. The unused, normally closed, pin on the relay was snipped off flush and insulated with a dab of hot glue. Otherwise, this pin would have been an exposed hot leg of 110VAC. Not a huge deal as everything is inside a plastic box, but it is a good idea to do.

Circuit assembly continued on a piece of perf board and was hot glued to the top of the relay which, in turn, was hot glued betwixt the arcade push buttons.

In the picture below, you can see where the hot lead of the extension cord is interrupted by the normally open contacts on the relay. You can also see a knot tied into the extension cord in the top left of the picture as strain relief.

Below you can see everything fits into the box nicely. What isn't too apparent is a pair of black wires coming out of the box too. I chose to use a wall wart transformer to power my circuit instead of the 110VAC coming into the box as this is just a bench top installation and not an, in the wall, permanent fixture.

Here is a video of the switch in action. You can see the camera adjusting it's auto white balance as the lamp I have the switch plugged into is turning on and off.

This project was a fun way to spend the afternoon. It certainly adds some geek cred to my electronics bench. I think I am more interested in a monostable 555 circuit attached to the relay output, however. That way, I could turn things on for a period of time and have them turn off automatically, instead of returning a day or two later to find out I left my soldering station on again.

Guitar Pickup Winder

2011-08-28T13:52:00.003-04:00

This projected started in June of 2011. Remember the Google Doodle commemorating Les Paul's 96th birthday? Well, that got me thinking about how electric guitar pickups work. I had a general idea about how they work, postulating they are essentially variable reluctance sensors, but doing a bit of research, I kind of got bitten by the electric guitar bug and dove right into the research of solid body electric guitars as a whole.

I have been primarily focused on guitar pickups and passive electronics at the moment. In short order however, I would be requiring a test bed for these pickups. That is why I made the decision from the very beginning that I would not only try my hand at building electric guitar pickups, but a complete scratch built guitar; wood has been harvested. Later posts will focus on other topics about solid body electric guitar building. Here, I will try to stay on the topic of an electric guitar pickups, but more specifically the pickup winder I built to wind my own pickups.

After announcing my new obsession to anyone who would listen, an electric guitar was given to me to experiment with. It is a smaller than average guitar, possibly for a child, but it will do just fine to test my pickups with a full guitar still being built down the road. Below is a picture of the pickguard with the old electronics installed.

Since I was going to be using an microcontroller to count the turns and stop the machine when the predetermined number of turns has been reached, I could make this winder do more stuff too. So, I made this pickup winder into more of a pickup winding station. Here is a feature list:

-Pickup Winding with turn counting, RPM, ETA and auto stop
-Stroboscopic guitar tuner
-Ohm meter for coil resistance measurement
-Gaussmeter for measuring polarity and magnetic flux density of pole pieces

I decided to use an Arduino to control my guitar pickup winder. I figured it would be a good way to put it into use. I bought the thing years ago and have only used it a couple of times. It really just gathers (figurative) dust as was the graphic LCD I used here too. I was glad to put some inventory to use in this project.

The code is ~850 lines so probably a bit much for inline posting with syntax highlighter. Instead, you can download the arduino "sketch" (code) below. Also, there is a link to a collection of free PDF's I came across while doing research for this project. There is some good information in there about guitar pickups. I also put a schematic for wiring my guitar in there too as I found the pictorial "schematics" confusing.

Files:

You can download the pickup winder schematic here.
You can download the v1.5 Arduino code here.
You can download the guitar electronics schematic plus PDF collection here.

The need for a pickup winder is obvious when you take a look at the construction of an electric guitar pickup. Essentially, there is a bobbin made from AlNiCo rod magnets and insulating material. Around this, there are ~6,000 to ~10,000 turns of 42 ga wire. Depending on the pickup, the number of turns of wire and the wire gauge will differ, but this approximation will illustrate the need for a machine that can turn the bobbin and reliably count the completed turns.

Here are some pictures showing the complete bobbins and the Jarrah wood spacers and tools for assembly. Everything is sitting on my tree stump anvil that I collected while sawyering in the above youtube video. The magnets are appropriately called "pole pieces" and this configuration is called "staggered". The height of the pole piece corrects for volume as the fretboard is radiused.

Also, 42 ga wire is tiny and fragile! Here is a microscopy photo showing the copper 42 ga wire on the right next to a hair from my head.

O Kapton! My Kapton! I wrapped the bobbins with Kapton tape to prevent possible abrasion from wearing thru the wire insulation and shorting out the pickup. I also super glued the inside joint where the alnico 5 rod magnets meet the flatwork to discourage pressing them thru and abrading the coil wire.

I looked up some commercially available pickup winders to get an idea of what I was trying to make. The speed ranges were all around 1000 RPM and variable. Some of the commercial winders have a thru axle offering "reverse" winding capabilities. I decided I can achieve "reverse" winding by mounting the pickup to wind "upside down" and the direction of wind will be opposite. This way I do not have to worry about motor direction control.

I found a variable speed motor in the form of a sewing machine motor in one of my many junk boxes. I made an infrared non-contact tachometer to measure the no load speed of this motor and was rather surprised to find that it turned at 10,000 RPM. Clearly this is way too fast even with the variable speed throttle pedal.

I did not give up on sewing machine motors, though and went to the ReUse center and found an old Remington sewing machine for $5. This machine was too sweet looking to hack apart so I decided to keep it as a sewing machine after a bit of tuning it up and make up an adapter to make it work for pickup winding too. Also, leaving the sewing machine in tact gives me the benefits of mechanical gear reduction, friction to help slow it down, a flywheel and a face plate area to mount an adapter for putting the pickup bobbins. It's a win-win situation.

Here is a drawing of the adapter jig. It mounts in the flywheel on the end of the sewing machine with three rare earth magnets as seen in the picture below. A ferrous piece of material, such as steel is screwed on to the aluminum jig to allow the pickup bobbin to be mounted with it's Alnico 5 magnets.

I found that the pickup bobbin mounted magnetically to the steel bar did not have a high enough coefficient of static friction; it would rotate with a small amount of torque applied yet it had quite a strong magnetic attraction to the steel bar. I tried a piece of duct tape, sticky side towards the steel plate, and it helped, but the real solution was gluing a couple pieces of sand paper on the outer edges of the steel bar, atop the duct tape as shown below. This allows for secure winding.

Below you can see how I mounted the pickup bobbin in "standard" orientation. This allows what is known as clockwise winding. The picture also shows how I used a straight edge to line up the wire guide stops. Those wire guide stops are mounted to a 3/8" diameter rod from the hardware store. The rod is held in place by a magnetic base dial indicator stand. All sewing machines that I am aware of have a flywheel on the side that rotates the same direction. Using the picture below for reference, the top of the flywheel moves to the left. This is anti-clockwise as you look at the front end of it.

In the following pictures you will see how I mounted the bobbin to the faceplate to allow "reverse" or anti-clockwise winding. I pressed some rare earth magnets into a piece of Jarrah wood. The pickup bobbin is charged magnetically so it's alnico 5 rod magnets are attracted to the opposite poles on the rare earth magnets. The rare earth magnets hold the Jarrah wood spacer and bobbin to the steel bar on the faceplate.

Did you happen to notice a piece of black electrical tape across the flywheel in any of the pictures above? That is for the infrared non-contact tachometer. You can check the schematic for more details on that. Since I am measuring rotation events over time (RPM), it is a trivial matter to count the total number of events (rotations) or coil winds. I am also able to calculate estimated time to completion based on current RPM and number of winds left. The software opens a relay when the number of winds is greater than or equal to the desired number of winds. This cuts the power to the sewing machine so it stops when you have the correct number of winds. Of course, inertia adds a few winds, but you can compensate for that by lowering the number of winds desired or just unwinding a few turns when you see how many over the machine went. It seems to overshoot by 10-15 turns due to inertia so I just set the desired turns number lower. That is a pretty complete description of the coil winder operation. There isn't much to it, but there is a lot of information on the internet and in books about coil winding that are worth a read.

You can see a picture of the non-contact IR tach sensor below. It has 2 magnets to attach to the cast iron sewing machine body.

Even with the gear reduction offered by keeping the sewing machine in tact and the added friction, I found the flywheel where my adapter jig is mounted still rotated too fast. I found it necessary to slow the motor down further and I did this by adding a "resistor" for the AC hot line of the sewing machine motor. I used a 100-watt light bulb for this purpose and now the final speed at the flywheel is a manageable maximum of ~1000 RPM. The throttle pedal still controls speed and the light bulb is inserted in the circuit with standard 110ac 2 prong plugs so it can be removed for high speed sewing. Below is a picture of the dimly glowing bulb acting as a resistor.

Here is a short demo video.

Stroboscopic tuner:

The stroboscopic guitar tuner works by flashing an LED at the resonant frequency of an in-tune guitar string. I made a guitar pick with an led on it to pluck a guitar string. An LED plectrum if you will. The pick was etched using the sharpie and ferric chloride method. It says "LED Guitar Tuner" on it. You aim the led at the string while it vibrates and turn the tuning machines of the guitar until the string appears to be still. Below is a picture of the LED pick and a video of the tuning in progress. It is a little difficult to see in the video but in person, the strobe tuner is quite effective. The video is taken after the pickups I made were installed in this guitar. The sound you are hearing is coming from an LM386 audio amp I made for a different project.

I have found in practice that the stroboscopic guitar tuner is much easier to use on the lower frequency strings. Like the low-E at 82.41 Hz. The video above is of the G string at 196 Hz and it is easy enough to see in person too. I guess, as with anything, practice is helpful to getting it right. You can use relative tone matching by ear for tuning the higher frequency strings. There is nothing to say you cannot strobe tune all strings with the strobe tuner, however.

Gaussmeter:

I think it will be useful to know the relative Gauss strength of the pickup pole pieces and knowing the polarity, north or south, will be paramount to success. Many websites on pickup making suggest using a polarity tester for determining polarity but, using a continuous, ratiometric hall effect sensor I can measure the magnetic flux density of the pickup pole pieces at 1.3mV/G as well as the polarity. This is an uncalibrated value, but it is sufficient for my purposes. The sensor I used is an Allegro A1302 hall effect sensor. In the gaussmeter mode, peak gauss values are recorded and instantaneous values are reported.

It is important to note that if the gaussmeter displays the polarity as "North", that means you have a "South" pole of a magnet facing it and your pickup is a "South" polarity pickup. This is the same as how a compass would work.

Ohm Meter:

Not too much to say here. There is a voltage divider circuit made with a 10k0 resistor and the guitar pickup under test. The instantaneous ohmic value is reported and peak value stored and displayed. I remember measuring the resistance of a coil right after winding. It measured ~6k2. After leaving it for some time it went down to 6k0. I believe the friction from my hand when winding caused the temperature to rise enough to cause this.

I had originally planned to make this pickup winder have an automatic wire feed traversal so it could wind coils on its own. I may get back to doing that at some point but for now I will "hand" wind them. That is, feed the wire to the spinning bobbin by hand. This seems to be the preferred method of winding of some musicians anyhow. I left a PWM channel available to connect a servo motor to at some point for this purpose should I choose to implement it.

Once the pickups are wound and wire ends soldered to the eyelets they are was potted. I wrap one round of kapton tape around the coil wire before potting in 20% beeswax and 80% by mass of gulf wax. I put the jar in a bath of ~160 Deg F water to melt the wax. I put the pickup in the wax and wait for it to come up to temperature. You can see in the video below that the pole pieces are that last to warm. The whole thing locally cools the was and it solidifies. Within about a minute, depending on the relative thermal masses the pickup is up to temperature and all the wax around it is remelted.

Once they are up to temperature I apply a partial vacuum to the jar removing air and replacing it with wax in all the nooks and crannies of the coil winds. Besides being good practice for durability of this tiny wire this also stops what guitar players refer to as microphonic pickups.

Here is a shot of the pickups wax potted and ready to be installed into the guitar. The black wire is the ground. I make the ground wire whichever eyelet is the coil finish so that the outer coils of the pickup can act as a shield also.

I wound my middle pickup to be opposite of my neck and bridge pickup. It will be reverse-wound, reverse-polarity for hum cancellation in guitar switch positions 2 and 4.

As far as charging the pole pieces goes it's pretty easy. Alnico is very coercive. I bring the assembled and potted pickup into contact with one pole of a strong rare earth magnet. I use a 3-inch diameter 400 lb pull magnet. I suspect you can get away with a much smaller magnet, that is just what I had on hand. So, if I want a "North" polarity pickup I bring the top of the pickup into contact with the "North" side of the charging magnet. The approach and withdraw is axial. Then I do the same on the other side bringing the bottom of the pickup close to the magnets' "South" pole. This makes the top of the pickup "North" and thus attracts a compass "South" needle, thus a "North" polarity pickup.

I installed the new pickups I made into the old pickguard. I had to whittle away some of the bass wood of the body cavity to fit an extra tone potentiometer. As I stated earlier, I have a reverse wound, reverse polarity middle pickup here. I wired them up according the the schematic I drew up and linked to above. I think this is the standard "Strat 2-tone wiring".

So, in the end, everything seems to have worked. It makes noise anyway. I am waiting for someone who knows how to play a guitar to come over and test it out, but I think I am off to a good start. If you have any suggestions on how to improve my pickups let me know. Or, if you have any tips on scratch building guitar bodies/necks that would be appreciated too. I still need to make a better case for the Pickup winder electronics. Probably a wooden box to set the plexiglass in to keep fingers and 110 vac separate.

A final "finished product" picture... for now anyway. Also, the missing string has been replaced already.

Halloween Spooky Eyes

2011-08-19T09:14:00.001-04:00

With Halloween approaching and a little bit of free time on my hands the other day, I decided to make a decoration to put in the bushes this Halloween. They are large 10mm diameter LED's glued to popsicle sticks. They are spaced apart to look like Halloween creature eyes hiding in the bushes stalking their prey. Are they after the bags of candy or the trick-or-treaters themselves? I hooked them up to a microcontroller to animate them by "blinking", not to be confused with flashing of course. You certainly could do a re-design and use 555 timers etc, but it seems more and more these days I have more microcontrollers in stock than I do 555 timers and the like.

I drew vertically elongated pupils with a sharpie on the LED's to add to the creature like effect. They are a bit hard to see in the video but they look good in person.

These LED's came from some discount store I don't remember when and as such I didn't have any specs on them. To find the forward voltage drop I applied 5v via a 1k0 resistor and measured the voltage across the LED leads. I measured ~1.7v on all of them. Here is a construction photo showing the current limiting resistors for the LED's.

I connected the LED pairs to an ATtiny2313 microcontroller via some comms wire and some 2n3904 transistors for each pair. You can see how spartan the circuit is in the picture below. If you would like a schematic of the spooky Halloween eyes you can download it here.

Hot glue offers some protection in the form of electrical insulation and mechanical fastening.

I have yet to install these eyes in the bushes, but initial bench testing suggests they are incredibly realistic creature eyes. I walked by the room where I was testing them and I was overcome with fear and froze in my tracks. The terror subsided when I remembered that the eyes are just a Halloween decoration; LED's and C code at that.

Since humans blink at about 3-4 blinks per minute when concentrating I figured that would be a good blink frequency to use for my creature eyes. The creatures could in fact have once been human before turning, we just don't know. Blink duration is 350mS. Here is the code to run 3 eyes. Feel free to modify it for your own use.

/* 
Title:		Spooky Eyes v1.0
Filename:	spooky_eyes_1_0_main.c
Author:		Pete Mills
Website:	http://petemills.blogspot.com
Date:		2011.08.17
uC:			ATtiny2313 @ 8 MHz internal oscilator, no prescale
*/

/*
Program description:

This program blinks LED "eyes".  The led's are mounted on popsicle sticks about the distance apart as 
human eyes are.  Hide the LED's in the bushes and they look like halloween creatures stalking you.
The blink frequency is that of a concentrating human at 3-4 blinks per minute. Blink duration is 350ms.
These timings are non critical and as such timing is derived from the ATtiny's internal RC oscillator.

Circuit Description:

The uC is an ATtiny2313 running on its internal oscillator @ 8MHz with no internal prescale.
The 10mm diameter led's are connected to PB0::2 via a 2N3904 transistor for each pair.  The led's are 
on the high side.  Each LED has a 120 ohm current limiting resistor.  

A schematic is available at https://sites.google.com/site/pemills2011/file/Spooky_Eyes_Schematic.pdf?attredirects=0&d=1

*/


#include <avr/io.h>			// defines things like "PORTB" and "TCCR0" etc
#include <util/delay.h>		// delay functions
#include <avr/interrupt.h>

#define EYE_PORT PORTB		// hardware port for spooky eyes
#define RED_EYE PB0			// red eyes
#define YEL_EYE PB1			// yellow eyes
#define GRN_EYE PB2			// green eyes

// global variables

volatile uint16_t red_ctr = 0;
volatile uint16_t yel_ctr = 0;
volatile uint16_t grn_ctr = 0;


// function prototypes

void setup(void);
void blink_eye(int eye);


int main(void)
{

setup();

uint16_t red_delay = 0;
uint16_t yel_delay = 0;
uint16_t grn_delay = 0;
uint16_t min_time = 15000; 	// minimum amount of time between blinks


	while(1)
	{
		
		if( red_ctr >= red_delay )
		{
			blink_eye(RED_EYE);
			// random time from ~0-5 sec plus min_time = ~15-20 sec between blinks
			red_delay = ( ( (uint8_t) rand() ) * 20 ) + min_time;	
			red_ctr = 0;
		}
		
		if( yel_ctr >= yel_delay )
		{
			blink_eye(YEL_EYE);
			yel_delay = ( ( (uint8_t) rand() ) * 20 ) + min_time;	
			yel_ctr = 0;
		}
		
		if( grn_ctr >= grn_delay )
		{
			blink_eye(GRN_EYE);
			grn_delay = ( ( (uint8_t) rand() ) * 20 ) + min_time;	
			grn_ctr = 0;
		}

	}

}


// functions

void setup(void)
{

// port config

DDRB |= ( ( 1 << 0 ) | ( 1 << 1 ) | ( 1 << 2 ) );		// set portB bits 0::2 to 1 for output
PORTB &= ~( ( 1 << 0 ) | ( 1 << 1 ) | ( 1 << 2 ) );	// set the outputs low


// timer config

OCR1AH = 0;							// interrupt @ 1khz
OCR1AL = 124;						// decimal 124, one less than 125000/1000 because 0 and TOP are counted
TCCR1B |= ( ( 1 << WGM12 ) | ( 1 << CS10 ) | ( 1 << CS11 ) );		// CTC mode, ck/div by 64 for 125000 Hz
TIMSK |= ( 1 << OCIE1A );											// enable OCR1A match interrupt
sei();
}


void blink_eye(int eye)
{
	EYE_PORT &= ~( 1 << eye );	// turn off eye
	_delay_ms(350);
	EYE_PORT |= ( 1 << eye );  // turn eyes back on
}


ISR(TIMER1_COMPA_vect)
{
	red_ctr++;
	yel_ctr++;
	grn_ctr++;
}







//

Here are a couple videos of the eyes in action.

In this video you can see some of the randomness in the trio of creature eyes. There is a minimum of 15 seconds between each set of eyes blinks then a random amount of time from ~0-5 seconds.

This was a fun afternoon project and I think it will be a fun decoration too. I hope the trick-or-treaters don't get too frightened and stay away...

Bat Detector

2011-08-12T14:44:00.000-04:00

If you are a reader of Make Magazine you may remember seeing a "Bat Detector" as a weekend project. That was back in 2006. In the summer of 2010 I ordered some circuit boards from Tony Messina who designed this circuit. And last night, in the summer of 2011, I finally put together 3 of these neat little ultrasonic frequency division bat detectors. It took a while, but it was totally worth it.

I wasn't able to record any bats as they were scarce last night, but here are a couple of sounds that have an ultrasonic component to them. Rubbing fingers together and water running from a faucet. The water faucet sound clip sounds very much like my Geiger counter in the presence of radiation.

I don't have much to say about the construction of the bat detectors. I really just wanted to post about them to help spread the word. I think it is great when makers like Tony share their circuits for all to enjoy and I also appreciated buying the circuit board from him as I wanted to make several bat detectors for friends. Below is a picture of an enclosure being modified to accept a bat detector circuit.

As for enclosures I just looked through my junk boxes until I found something that would work. In the picture below you can see I used a slot car throttle for one of them. It almost closes all the way but the 9v battery I put in the handle is just a touch too big.

The other enclosures I used are a cell phone holster with the plastic box from a laser pointer inside it and just a plain old black otter box. I think the otter box will be useful when camping because it is waterproof until you open it up to use it and the slotcar throttle is neat because it kind of looks like a ray gun from science fiction. Future upgrades include bat like graphics to be applied.

I am really pleased I finally put the time into making these. It took about an evening for all three including enclosures. Right after finishing the first one I took it outside and within 5 minutes I heard a clicking sound. I looked to the dusky sky and there was a bat fluttering about before flying off over the roof. I didn't see or hear anymore bats that night, but that one literally put a smile on my face. Too fun!

Final thought; Go do this, but don't drag it out for 5 years like I did.

Engineering a Bow Tie

2011-07-25T11:52:00.008-04:00

I purchased this sewing machine from the local recycle center a couple weekends ago for $5. I bought it for another project I am working on that is unrelated to sewing, but I needed the motor. Well, I was so impressed with how cool the machine looks I couldn't bear to scavenge the motor and discard the rest. Instead, I decided to get the sewing machine to a working state and modify the design of my other project so that I could leave the machine intact. I will still use this sewing machine for the intended project but now, after a couple of minor tune ups I also have a sweet looking sewing machine.

All I really had to do to get the machine working was reinstall the thread tensioner, oil it and replace the motor brushes. And with a little help from my Mom and a friend of mine I was able to understand better what all of the different parts of the machine do. Sewing machines are really incredible. They have all kinds of interesting cams, connecting rods and leavers. One source of amusement for me during this process has been learning the new terminology. For instance I still have a tendency to call the "stitch length" "feed rate" instead. If you are wondering what goes on beneath the bedplate of a sewing machine have a look at this lock stitch gif.

Now that I have a working sewing machine what will I make? Since I wanted to stitch something manly and easy and since I needed to get a bit fancy to go see my friend Linda in a play this weekend, I decided to make a bow tie. Which got me thinking; bow ties are better! Especially for hands on type people, comparing a bow tie to a neck tie the benefits are obvious. Bow ties don't dangle down and get caught in rotating machinery or get soiled as they flap about in the breeze. Bow ties don't have to be thrown over your shoulder to pee. Bow ties send the message that you are fancy, but ready for action at any time. Bow ties don't dangle into stove burners when you are cooking. I have never burned a bow tie with acid. And empirical evidence has proven I get more compliments wearing a bow tie than I do with neck ties.

Before we make the bow tie I will offer this disclaimer. I am not a seamster. I felt much more at home working on the machine than with it. In fact, this is my first time using a sewing machine really and as such there may be better ways to do things. Probably like how to sew the left and right halves together for instance. So, if you have any thoughts feel free to offer your suggestions in the comments below. I'd love to hear them. Also, I have made three bow ties now, some of the pictures I may use here are from different ties but were selected to best illustrate the steps. Don't worry if the fabric print changes on us half way through the blog.

A sewing pattern is a template used to cut out your fabric pieces prior to sewing. I looked online for a bow tie pattern, but I found none suitable. Instead I looked at an untied bow tie and a diagram of how to tie them. This led me to conclude that the knot size is a function of the neck band width and the minimum distance between the two concave radii on the outer ends determines the bow "pleats" or how much it crunches down when you cinch it up. With this in mind I fired up my favorite drafting program AutoCad and made some critical points. I used the spline tool to connect them which is similar to a French curve for the old school drafters.

UPDATE:
In case you really want to get nerdy I made a new pattern. I call it a "cosine function bow tie pattern" because the shape of the bow tie I designed is 2 cosines. I wrote the functions on the pattern in case you want to know what they are. You can download the cosine function bow tie pattern here. Both patterns use the same instructions outlined below.

You can download a PDF of the original pattern I made here. You will notice that there is one "bow tie end" and two neck templates. I only needed one neck template, but there is another one included for larger necks. Once everything is cut out, tape the neck template to the bow tie end where the arrow points to a line. The arrow is coming from the text that reads "shirt collar in cm between here and other side". Do tape it so that the neck template remains in line with the bow tie template. Below is a picture of how I lined up the template. Using a sheet of paper that touches a tangent point on the bow center and the intersection of the neck template line and the sew line on the neck template, the paper projects off to the right and makes a line to line up the neck template. The extra sheet of paper is removed and I taped the two templates together.

From here you can mark your neck size. My neck is 42cm circumferentially and since the pattern makes half of the bow tie, I marked 21cm on the template. Er, pattern, I mean. If we call this the left or right side, the 21cm mark marks a line of symmetry. Each half of the bow tie should be sewn together at this line and it will fit your neck just right. I decided against an adjustable neck strap because I feel my neck is probably done growing, I can make another one is necessary and ease of assembly with my limited sewing skills. Here is a picture of the 21cm line marked and the neck template taped to the bow tie template.

A couple words on materials. Firstly there is this stuff called interfacing. It is a horrible scratchy stiff material. It feels like wax coated coffee filter papers or course tyvek. I comes in an optional iron on version whose glue I presume would affect the color of your fabric. The purpose of interfacing, to my knowledge, is to stiffen up your sewn piece so; it is supposed to be good for things like...bow ties. I didn't use interfacing for interfacing and chose a fabric called muslin instead. It is soft and pliable and with two layers of it in between my outer bow tie fabric, it stiffened it up just enough to hold its shape and still bend out of the way should your chin ever come in contact with your tie. Safety first.

The second thing to note about fabric is that it stretches more on the bias, 45 degrees from the fabric threads. When you lay out the pattern on the fabric for cutting, place it so that it runs 45 degrees to the grain of the fabric. Pin the ~~template~~ pattern in place so it won't move when cutting. I cut out all of the pieces at once. This is probably not the best way to do it especially since my scissors are a bit dull from cutting a PCB days earlier. Here is a picture of the pattern pinned in place, on the bias, ready for cutting. In total there are 4 pieces of muslin and 4 pieces of outer fabric.

Cut out the entire pattern outline. You want to leave material beyond the neck circumference mark you made earlier so you can sew the halves together later.

Here are three versions of neck seams I made. The brown one in the center is probably the best design wise but the yellow and blue are easier and covered by your shirt collar anyway.

For the yellow and blue I started by sewing the left and right halves first around their perimeter and turned them right side out. For the blue one, I overlapped the halves at the neck seam mark I made on the neck template and ran it thru the machine then chopped off the "tag ends". For the yellow, I laid the left and right halves on top of each other and ran it thru the machine at the neck seam mark, then ironed the tag ends flat. For the brown one, I did not sew the left and right halves together first. Instead I sewed the top or front, left and right halves together first, ironed that flat then sewed the perimeter. Perhaps a photograph can best illustrate the brown neck seam.

Still talking about the brown one, I then sewed the perimeter leaving the vertical slit open for turning the thing right side out and hand stitched it closed. I guess it is a good time to mention you do all of the sewing possible inside out and turn it afterwards so it hides the stitches.

Back to the yellow and blue ties and sewing the perimeter. Prepare the left and right halves inside out so that the fabric sandwich has two pieces of muslin, one each on the outside and your two pieces of outer fabric, good side facing each other are on the inside. Pin the whole thing together and sew around the perimeter. I used the presser foot on the machine as a guide to know how far in to stitch. Below is a picture of this step. The photograph also shows the two concave radii that I was talking about earlier that will increase the pleats in the tied bow if you increase the distance between them.

Once the perimeter is sewn you will want to cut incisions around the perimeter wherever there is up or down concavity and at inflection points. That is, anywhere the sewn line is not intended to be straight, cut some incisions to help the flat fabric bend in the curves when you turn it right side out. I imagine this is less necessary when you sew as close to the edge as I did, but I guess it is still good practice. I also imagine I put more incisions than are necessary. This is also a good time to trim fabric from what will be internal corners of the bow tie. Just trim the fabric kind of close to the stitch line, but not too close that the fabric unravels, where the internal corners will be to reduce fabric bulk.

Now, whether you chose to do the brown bow tie neck seam or the easier blue or yellow style neck seam it is time to turn the tie right side out. To do this I used a chopstick. I also used said chopstick to poke the corners of the bow out to sharper points before ironing the thing flat.

Once the bow tie is turned right side out I ironed it flat and turned to youtube to learn how to tie a bow tie. Turns out its pretty easy. I'd say it was less difficult to learn to tie a bow tie than it was when I learned to tie a neck tie. In fairness I was probably 8 back then and my only bow ties were clip on.

So, if you feel like getting fancy and are tired of the limitations inherent to neck ties give bow ties a try! Let me know if you give it a shot, I would be interested to get some feedback on the pattern as well as technique. Here are a couple of action shots and one of my sewing 'rig' because I like the way it looks.

SpinArt Desk

2011-06-26T22:01:00.001-04:00

Making things is just so much fun and taking on new projects is a rewarding experience where you can learn something new. Take this SpinArt machine for example. I went to the local ReUse center last week and as usual, I didn't know what I was going to find. I didn't have the desire to make a SpinArt machine at the time, but the idea came to me when I found an old school desk there for $10. I thought it would be a great "ReUse" to put a rotating platter inside the flip up top and call it a SpinArt machine. Of course, the "Art" part of the name as it relates to the methodology is subjective and I really want to call it a "Centrifugal Pigment Accelerator", but in the name of effective communication I will reluctantly call it a SpinArt Machine.

Now, a SpinArt machine, no matter how good it looks, really isn't a piece of furniture I need around my house. It was great fun to make and even the first few paintings were fun, but it should find a new home and I know just the place where this will be right at home and that is the Mt Elliot Makerspace in Detroit. I have been spending a fair amount there recently helping my friend John setting up the wood shop. There is a lot of work to do still, but it is nice to see progress being made. This weekend we were painting the ceiling in the wood shop. I also took a break to paint the SpinArt machine desktop when I was there. I plan on taking the SpinArt machine down there next time I ride in a truck and hopefully I will be able to get some video of the thing in action. It is a little hard to film and operate it at the same time.

According to the Wikipedia entry for Spin Art, this method of painting has been documented since 1958. The way "SpinArt" works is that you have, whatever it is that you want to paint, attached to the platter, then you turn on the machine to spin the platter and when it is up to speed, you drop paint onto whatever it is that you are painting. If the platter is spinning fast enough, the coefficient of friction between the paint and painted surface is high enough and the viscosity of your paint is low enough, the centrifugal force acting on the rotating paint will draw itself out radially from the center of rotation. Several things will affect the pattern as it is painted. Most notable are the aforementioned angular velocity and paint viscosity ,but also, the rate of change in angular velocity will impact the finished painting.


Here is the "before" pic of the desk as it sits outside the ReUse Center

I think the picture below will give you a good idea of everything that is going on here. There is a motor underneath the wooden disk inside the desk. Outside is the speed control (more on this later) attached to the side. You can also see a lamp and the cord to power it all on the ground. It really is that simple, but I will go into some details in a moment.

The motor came from a box fan. I mounted it to the inside of the desk using a couple of pieces of poplar wood. Where the poplar wood makes contact with the ribs in the desk, I cut out some neoprene sheet to put in between. This is not so much for vibration dampening as it is to keep things from slipping and subsequently loosening the screws.

The fan motor is an induction motor and as such, cannot be speed controlled with an ordinary incandescent dimmer switch. I confirmed this to be true by trying to use a lamp dimmer to control the speed of the motor with nothing attached to the output shaft. Then, I tried adding a 60W light bulb in series with the motor. This allowed me to have the speed control I desired using a cheap ~$8 triac chopper dimmer (aka ordinary incandescent lamp dimmer). I believe this changes the power factor of the motor allowing the necessary speed control.

So, the wiring goes like this. The hot leg of the 110VAC coming into the blue speed control box on the side goes to one lead of the lamp dimmer. The other lead of the lamp dimmer goes to one lead of the lamp base cord, I chose the center pin lead to be consistent with conventional wiring and not the threaded part of the lamp base. The other leg of the lamp cord goes to what used to be the hot side of the motor switch and the neutral side of the fan switch goes to the neutral lead of the wall power. Turn the 3-way power switch that came with the box fan to the highest setting and pack it all neatly in a plastic 2-gang switch box making sure all wires are properly and securely connected.

Here is the original motor speed selector switch getting wired up to be put in the blue speed control box. I set it to the highest setting before connecting the dimmer and closing up the box.

I made the rotating platter by cutting a disk from a piece of 3/4" birch face plywood then cleaning up the cuts on an upright belt sander. A thru hole was drilled for the diameter of my motor shaft and a counterbore was made for the left hand motor shaft nut to sit in. This way the motor shaft nut will not protrude above the surface and "dome" your painting. I chose 13.9" as O.D. (outside diameter) of the platter because Pythagoras told me to. That is the "hypotenuse" of a standard sheet of paper 8.5"x11" thus, a piece of printer paper will fit just right on the platter. You can download a drawing I made of the platter here.

After installing the platter on the motor shaft I measured the runout on the O.D. to be no more than 0.01". It is important to remember that this platter is going to be spinning pretty fast so you want it to be well balanced. Mine actually has a vertical deflection when it rotates and I need to look into this as it creates a vibration at a particular speed. Currently, I just don't run it at that speed instead, going faster or slower.

And speaking of mounting the platter to the motor shaft, it was necessary for me to buy a motor shaft collar from the hardware store. You can see it on the motor shaft in the picture below. I set it so that the distance from the top of the shaft to the top of the shaft collar was less than the thickness of my wooden platter (3/4") and then turned the grub screw with an allen key to lock it in place. In the picture below the collar is not set to the correct height yet, it is intentionally set too high for the sake of picture clarity.

I decided to paint the top of the desk "SpinArt" style before mounting the motor in place. I found a couple of cans of house paint in the woodshop at the Mt Elliot Makerspace so, that is how the color was decided. I quickly found out that I needed to thin the paint with water instead of using it straight out of the can to help it flow better and fling out. To spin the top I very carefully measured the center of the desktop and mounted the box fan propeller to the underside of the desktop with 3 screws. I slipped this onto the motor shaft and with paint applied set it spinning. You can see how that all went in the raw and unedited footage below.

Weird stuff happens in the end of the first video here. I think the way the camera draws the lines of each frame of video and the rotating of the desk lid makes it look like it is morphing into a different shape. I assure you it is not. There are some pics below of the same phenomenon.

After the spinning stopped this is what the desk lid looked like. I can see where some of the paint started drying before it got all the way out to the edge. I think it looks pretty neat and it figuratively says "I am a SpinArt desktop", but as you can see in some later pics it literally says "SpinArt" on it because my mother was nice enough to cut out a custom stencil and stencil the word on there for me.

Here is a pic I took while the desktop was spinning and paint was getting on my leg hairs. There is a pretty interesting digital photography anomaly going on here.

For a finishing touch I bent a coat hanger and put some heatshrink on the ends to hold this wire basket for the paint bottles. As far as paint goes, I have both washable and Tempera paint. Again, thin it out before use.

I use "Removable Mounting Putty" to stick the paper to the platter. It seems to work pretty well.

As an extra precaution, I decided to make a cardboard paint guard to stop stray paint exiting the desk cavity. It also keeps the inside of the desk a bit cleaner and you can just throw the cardboard away when it gets to much paint on it and make another one. It folds up when you are done and can be stored inside the desk.

So, this was a pretty fun project and I think a good "ReUse" of the school desk. It took about two days and ~$30 to make but I did have a lot of materials already. There isnt much more to say about it so I think I'll just bang a few more photos up here and maybe a vid and call it a day.

In this video, you can hear the paint splattering off and hitting the cardboard.

Real Time Clock - Part 1

2011-05-19T23:21:00.001-04:00

I'm not sure why it is, but electronic hobbyists like to make clocks. We seem to be thrust towards them like electrons to a phosphor coated screen in a cathode ray tube. Although, at a much lower velocity. Nevertheless, I somewhat recently decided it was time to make a clock for myself. I quickly came up with several ideas of the physical implementation e.g. alarm clock, ceiling projected display etc., but as I found out that is the easy part. I was able to distill every clock design down to the need for an (acceptably [more on acceptable accuracy later]) accurate time base, most likely 1Hz and that is what this post "Part 1" will focus on. I will attempt to offer rational explanations as to why I decided to do things the way I did because, in case you didn't know, there are more ways to make a time base than there are numbers on a clock's face. Here's how I cut my teeth skinning this kitten.

Firstly, this is going to be a microcontroller based implementation of a real time clock. Here, "Real Time Clock (RTC)" means only: a device used to keep track of time in human readable units. Basically, its a clock clock. Since my finished clock will have other tasks to perform in addition to keeping track of time, such as sounding an alarm or initiating an elaborate rube goldberg machine responsible for starting my car in the winter months, making my 1Hz timebase on the uC is a logical choice.

Independent RTC IC's:

I didn't immediately dismiss the idea of separate IC RTC's. They look so promising! They keep track everything one could hope for! The last statement is A) wrong and B) misleading if it were true. From the DS1307 product page: "Real-Time Clock (RTC) Counts Seconds, Minutes, Hours, Date of the Month, Month, Day of the week, and Year with Leap-Year Compensation Valid Up to 2100". But, wait a minute, if I have an accurate timebase inside my microcontroller, several lines of code later you can have all that functionality, without adding an extra part or adding the arguably small price to the project. I think the DS1307 is about $1.00. Besides, I am making a clock; if I wanted an off the shelf solution I'd hop in my Koenigsegg and head over to IKEA for a Slabang and some meatballs.

Another nail in the separate IC RTC coffin is that the DS1307 uses a standard 32768 Hz watch crystal to run it. If I really wanted to use a watch crystal (which I don't, particularly), it would seem obvious to hook it up to the asynchronous timer on the ATMega328 that I am using for clock development. The accuracy of the DS1307 is dependent on the accuracy of the watch crystal being used and matching the load capacitance on the board and the load caps with the spec in the crystal datasheet. In other words, that 32768 Hz crystal is not going to be ticking over at 32768 Hz and there is no way to compensate (calibrate) for that except using a trimmer cap and a frequency counter to adjust the frequency, at the temperature of the crystal during calibration. If instead you had a watch crystal on the asynchronous timer of the ATMega328 you could implement a software calibration, but more on that later.

I am picking on the DS1307 because it appears to be so popular. There are many other RTC IC's but for illustrative purposes that is the one I chose. To get around some of the issues of accuracy outlined above you could use the DS3231. It has a TCXO and claims accuracy of +/- 2 ppm. +/- 2 ppm is getting pretty good (we can do better). That equates to about +/- 1 second in 6 days. But, they are expensive. At about $9 they are twice what an ATMega328 costs. And for some of the same reasons the DS1307 isn't that great of a deal, neither is the DS3231. Basically, the allure of the DS3231 is in its accuracy of +/- 2 ppm; as way to avoid having to write some time keeping code it too goes against my geeky DIY nature.

Daylight Savings Time:

Daylight savings time is a pain in the neck for a clock designer. Within the US not all states abide by daylight savings time and international protocols for DST do not, to my knowledge, exist. The text from http://aa.usno.navy.mil/faq/docs/daylight_time.php that says "Starting in 2007, daylight time begins in the United States on the second Sunday in March and ends on the first Sunday in November." illustrates the difficulty in programmatically adjusting for DST, but more notability, the fact that DST protocols can and do change. Imagine having recently finished your clock design. One where it will dutifully adjust for DST for you, only to find out the accepted standard for when DST changes, has itself, changed. You are then faced with rewriting your code for the new standard or adjusting, no longer twice a year for DST, but four times, assuming both the adjustment forward and backward have changed dates. Because of these issues, I have decided to forgo automatic updating of DST on clocks that are self contained, that is, on clocks with no external time synchronization such as NTP, GPS, WWVB, etc, I will instead, adjust the clocks time manually on DST.

Leap seconds:

Leap seconds are adjustments made to UTC (Coordinated Universal Time) because cesium fountain time standards in use are more stable than the Earth's rotation around the sun. This Copernican anomaly may ruffle the feathers of geocentrists, but every year on June 30 and December 31, the International Earth Rotation and Reference System Service may or may not issue a leap second depending on necessity. The last one was added December 31, 2008.

Here is a highly gratuitous photo of some nerd bling aka LED edge lit plexi glass.

With these constraints in mind I decided it is better to have a stand alone clock that you are able to adjust the time on rather than have a clock with high accuracy, set to run an entire life cycle, only to find that some adjustment outside of my control adjusts UTC. Which brings me to acceptable accuracy.

I define acceptable accuracy as some balance between cost and external constraints. For example, I have decided not to automatically adjust for daylight savings time which occurs twice a year, because it can change. Currently it is on the second Sunday in March and on the first Sunday in November. Since this is a maximum time of about 8 months between setting the time. I only need to be acceptably accurate for up to 8 months. I think I can live with anything up to 1 minute off. The only real way to know if the clock is displaying something other than correct time would be to compare it to NTP on a cell phone or computer. This is an arbitrarily chosen value but it should give me a start. One minute in 8 months is approximately 2.9 ppm. So, my goal will be to calibrate my clock to better than ~3 ppm.

When I first started this project I thought I would slap a 32768 Hz watch crystal on a uC and call it a day. Well I did that, and wrote the code to keep track of hours, minutes and seconds in a day and set it running. It was off by -4 seconds in the first 24 hours. I checked the code, double checked the load capacitor values and found nothing wrong. I believe the stray capacitance on the board and the uC pins was pulling the frequency of the watch crystal ~-46 ppm. Well beyond the +/-20 ppm tolerance of the part. Clearly this was unacceptable. I needed to buy a variable capacitor to tune the load capacitance so that the frequency was within my tolerance of ~3 ppm.

But, instead I started thinking of software solutions. Code is free for me to type and I don't have to wait for it to arrive from DigiKey. I first thought of adding 4 seconds to the display at say 2 AM when I should be fast a sleep. This idea bothered me on many levels, but using the 32768 Hz crystal I had setup my asynchronous timer for an interrupt fired at 1 Hz. What was I to do but get more resolution...

Here is another photo of the LED edge lit plexiglass. Shown only to break up all of those words in this blog post.

Selecting a new crystal oscillator I picked a higher frequency 16384000 Hz crystal with a +/- 10 ppm over -20C to 70C range thermal stability. Digikey part number 887-1245-ND. They are currently $0.48 each in quantity of 10. I am much more interested in a crystal's frequency as a function of temperature than out of the out of the box accuracy since I will be calibrating the clock in software which you can read about below. This type of crystal has a different cut on the quartz compared to a watch crystal too. A watch crystal will always lose time when its temperature is above or below 25C, where as my crystal has a frequency vs temperature curve that is a sine function with its origin at 25C. That is, above 25C it has a higher frequency and below 25C it's frequency is lower.

Side bar. I also needed a way of measuring frequency more accurately than an oscilloscope so I bought a cheap Chinese frequency counter, a VC3165. Other than the incredibly dim 7-segment display the frequency counter functions quite well. I was leery of purchasing it, but it uses a TCXO so I hoped it would be pretty accurate. Unfortunately, it cannot be calibrated. I opened it up and there is no adjustments to be made. I was able to experimentally derive it to be accurate to ~-2 ppm though. So it should be fine for most work. Certainly -2 ppm falls within my 3 ppm self imposed tolerance.

So, I've ended up with an 16384000 Hz crystal and setup my interrupt service routine (ISR) to fire every millisecond. Now, I can adjust in software on the mS level and it will be totally transparent to the clock user as current plans call for seconds display as optional. Even if I were to display milliseconds you couldn't read them fast enough to notice the adjustment.

To make the adjustment you just add a millisecond every x-number of (1mS) ISR cycles. For x = F_CPU / ( F_CPU * error_in_ppm ). In my case I had my ATMega328 running on a 16384000 Hz crystal. I set the CKOUT fuse to output the system clock frequency on pin 14 to measure the undivided system clock on my frequency counter and got 16383480. A difference of -31.7 ppm. since x = 16384000 / 16384000 * -31.7x10^-6 = 31508 (rounded up) , every 31508 mS aka every 31508 ISR cycles I add (because it was running slow) one millisecond.

Here is a snippet of my ISR. Don't do this. I just threw this code together for testing my clock ideas. In practice you want to handle everything other than updating the millisecond counter outside of the ISR. I will make that change when I write my final clock program.

//This interrupt is called at 1kHz

ISR(TIMER1_COMPA_vect)
{
 static uint16_t milliseconds = 0;  // mS value for timekeeping 1000mS/1S
 static uint16_t clock_cal_counter = 0; // counting up the milliseconds to MS_ADJ
 const uint16_t MS_ADJ = 35088;   // F_CPU / (F_CPU * PPM_ERROR) 
 const uint16_t MS_IN_SEC = 1000;  // 1000mS/1S
 
 milliseconds++;
 clock_cal_counter++;
 
 
 if( milliseconds >= MS_IN_SEC )
 {
  milliseconds = 0;      
  ss++;    // increment seconds
  toggle_led();   // toggle led
 
  if( ss > 59 )
  {
   mm++;   // increment minutes
   ss = 0;   // reset seconds
  }
 
  if( mm > 59 )
  {
   hh++;   // increment hours
   mm = 0;   // reset minutes
  }
 
  if( hh > 23 )
  {
   // increment day
   hh = 0;   // reset hours
  }
 }
 
 
 // milliseconds must be less than 999 to avoid missing an adjustment.
 // eg if milliseconds were to be 999 and we increment it here to 1000
 // the next ISR call will make it 1001 and reset to zero just as if it 
 // would for 1000 and the adjustment would be effectively canceled out.
 
 if( ( clock_cal_counter >= MS_ADJ ) && ( milliseconds < MS_IN_SEC - 1 ) ) 
 {
  milliseconds++;
  
  // it may be that clock_cal_counter is > than MS_ADJ in which case
  // I want to count the tick towards the next adjustment
  // should always be 1 or 0
  
  clock_cal_counter = clock_cal_counter - MS_ADJ; 
 }
 
}

Next I ran my clock again. I synched it's time to NTP and checked it again daily. After 6 days however, I found that my clock was about 1 second fast compared to NTP. Recall above that I said my frequency counter was ~-2 ppm off well, this is how I found this out. Had my frequency counter been calibrated to be spot on, my NTP test would have revealed I am only off in time by rounding errors in my ppm error calculations above. Or approximately -0.3 ppm.

My results thus far are acceptable and fit into my arbitrarily defined tolerance. In my research however, I came across a program written by an AVR freaks member that you can use to check the frequency of a clock if you don't have a frequency counter. I figured this would be good information to relay for those without frequency counters and who want to try and replicate what I have done here. You can find the program here.

Using the same 16384000 Hz crystal on my avr I setup an ISR at 1 kHz that toggles an output pin. I connected that pin to the RxD line on an FTDI cable and ran the program. Some samples were wildly wrong as the author suggests could happen so, I discarded those and averaged the remaining 17 Hrs of data to come up with an error of -28.5 ppm. Subtracting my new error from my frequency counter calculated error above yields (-31.7) - (-28.5) = -3.2 ppm. I expected this to be approximately -2 ppm, however, there were a lot of indirect methods used here and a bit of rounding. Not the least of which is the ~1second/6days estimation when comparing my clock to NTP with visual inspection. Having said all that, I am more apt to believe the -28.5 ppm error from the Network Frequency Transfer program at the moment and say my frequency counter -3.2 ppm off.

FTDI cable RxD line on uC pin 14

Going back to the calibration value calculations above you will see my new MS_ADJ value will be x = 16384000 / 16384000 * -28.5x10^-6 = 35088 (rounded up) or every 35088 mS aka every 35088 ISR cycles I add (because it was running slow) one millisecond.

That is a lot of theory, calculations and measurement. The proof really, is in the pudding. Real world application of the code and derived calibration value is what is needed now. Currently I have the clock running is a room that gets arbitrarily cold at night and warms up during the day. Just like it will see in operation. I synched it to NTP when I started it and I will check the deviation daily.

So, it has been 3 days and 4 hours since I started my clock synched to NTP and there is no visual deviation from NTP. The way I check this is I have an app on my phone that gets NTP and displays it with 1 second resolution. First, I check that my app and the clock are displaying the same value down to 1 second and then with my peripheral vision watch an LED on my clock toggle at 1Hz while I am watching the app on my phone. I have found during these experiments that using this method I am able to detect a deviation of as little as 50mS quite easily. This is possible only at the change of the seconds value i.e. the NTP app ticks over and I can see the LED turn on slightly before or after. I could not estimate say a half second or a quarter second with the same 50mS resolution.

Back to the numbers. As I said it has been 3 days and 4 hours since I started my clock run and I cannot see any deviation in clock time v.s. synched NTP time. If I say I cannot see deviations less than 50mS I will assume the worst case scenario and say it is 50mS off. ( 1 / (run_time / error) ) * 1x10^6 = error_in_ppm so, ( 1 / ( 273600 seconds / 0.05 seconds ) ) * 1x10^6 = 0.18 ppm. That is pretty darn good and cheap too boot!

This is far from a clock yet. Yes, it tells time in human readable units, but I still need to implement a calendar, power outage protection, alarm functions and make it do something cool. Maybe display moon phases? Time will tell...

I really learned a lot through this project up to now. I certainly did not end up with anything close to how I imagined I would implement a clock and I am rather pleased with the outcome and deeper understanding of timekeeping. My hope is that I was able to present some of the information I learned in a way that it can be useful to others too. I think "Part 2" will have a more refined clock-like appearance to it both in software and physical implementation.

Magic 8 Thing

2011-03-20T21:28:00.003-04:00

For about a week now I have been staring at a cellphone charger my friend Caitlin gave me to repair after she had loaned it to some chimpanzees for apparent durability testing. I was debating on whether I had put the repair off long enough, when, with no humans in earshot to ask, I figured I would build a Magic 8 Thing and ask it if I could procrastinate any longer. Was this a lack of motivation to repair a cellphone charger or was it motivation to make a Magic 8 Thing. Irrelevant really as I got both things done in about 10 hours this weekend.

For those who don't know what a Magic 8 Thing is, it is a Magic 8 Ball, made with an ATMega328, an LCD, a surplus mercury tilt switch from a retired thermostat and some code. I call it a "Thing" instead of a "Ball" because my version is both non-spherical and bears no functional resemblance to an actual "Magic 8 Ball". It does, however, have equal effectiveness in helping you make important life decisions.

I wanted to be able to physically shake the thing to illicit a response to my questions. And, since I wanted this project to be done quickly i.e. no ordering parts I was thinking about making a "shake" switch out of a couple of quarters and a pachinko ball. But, instead, while rooting through one of my many "stuff" bins I found an old thermostat with a mercury tilt switch. This has an unanticipated side effect of being able to hear the mercury sloshing around when you shake it. It is cool, it almost sounds like the original Magic 8 Ball that has the answer icosahedron floating in it. If I had my druthers, however, I would have used an accelerometer like a normal human to detect the shakes, but I have none at the moment.

You can see the mercury switch in the picture below. It is hot glued to the lower left of the circuit board. The header at the top connects the LCD which is mounted in the lid of this enclosure. Space and time were limiting factors on this build so, component layout was adjusted accordingly. E.g. jamb the bits in where they fit.

Here is a schematic.

And the code.

/*
Program Tile: Magic 8 Thing
Filename: ATMega_328_Magic_8_Thing_v1.0_main.c

Date: 2011.03.20

Author: Pete Mills
http://petemills.blogspot.com/

ATMega328
Ext. Crystal Osc. 8.0-    MHz; Start-up time PWRDWN/RESET: 258 CK/14 CK + 4.1 ms
*/

/*
Program description

This program uses an ATMega328 to interface an LCD and a Hg "shake" switch.
This is actually a mercury tilt switch from a retired thermostat.
rand() is called to generate a random value for a switch statement.  There are 
20 possible answers based on the original "Magic 8 Ball" toy.  The responses were 
found on wikipedia and modified very little.

The LCD library is written by Peter Fleury and can be found at http://www.jump.to/fleury
You will need to modify lcd.h to fit your port connections.

The user is to ask the device a question then shake the unit.  The device then
responds with one of 20 answers ranging from affirmative to negative and somewhere
in between.  Don't shake it too hard or it will tell you to "Stop It! before giving
you an answer.
*/

// Includes

#include <stdlib.h>
#include <avr/io.h>     // defines things like "PORTB" and "TCCR0" etc
#include <util/delay.h>    // delay functions
#include "lcd.h"     // LCD Library
#include <avr/interrupt.h>


// Definitions

#define LED_PORT PORTD
#define LED PD1      // LED pin PORTD Pin 2


// function prototypes

void setup(void);
int is_shakin(void);

// Global 

volatile uint8_t shake_count = 0; // counts up the mercury switch contacts, overflows for entropy
volatile uint16_t seconds = 0;  // seconds counter

int main(void)
{

setup();  
sei();        // enable global interrupts
lcd_init(LCD_DISP_ON);    // initialize display and turn off cursor



 while(1)
 { 
 
 uint8_t rand_num = 0;   // random number from prng seeded w/ shake_count
 
 lcd_clrscr();     // clear display and put cursor @ home
 lcd_puts("Magic 8 Thing\n"); // line 1
 lcd_puts("Ask and Shake");  // line 2
 
 while (is_shakin() == 0);  // while nothing is happening
         // now it detected a shake
 
 _delay_ms(500);     // wait a second er, half
 
 lcd_clrscr();     // clear display and put cursor @ home
 
 while (is_shakin() == 1)  // wait for the shaking to stop
 { 
  lcd_puts("Stop It!");  // line 1
  _delay_ms(2000);
  lcd_clrscr();    // clear display and put cursor @ home
 }
 
 srand(shake_count);    // seed the prng with shake_count
 rand_num = (uint8_t) rand(); // get a pseudo random number from 0 to 255
 
 lcd_puts("Magic 8 Thing\n"); // line 1
 lcd_puts("Says...");   // line 2
 
 _delay_ms(3000);
 
 
 // the responses...
 
 lcd_clrscr();     // clear display and put cursor @ home
 
 switch (rand_num % 20)   // pick an answer
 {
  case 0:
   lcd_puts("As I see it, yes\n"); // line 1
   //lcd_puts("blank");   // line 2
  break;
  
  case 1:
   lcd_puts("It is certain!\n"); // line 1
   //lcd_puts("blank");   // line 2
  break;
  
  case 2:
   lcd_puts("It is decidedly\n"); // line 1
   lcd_puts("so.");    // line 2
  break;
  
  case 3:
   lcd_puts("Most likely.\n");  // line 1
   //lcd_puts("blank");   // line 2
  break;
  
  case 4:
   lcd_puts("Outlook good!\n"); // line 1
   //lcd_puts("blank");   // line 2
  break;
  
  case 5:
   lcd_puts("Signs point to\n"); // line 1
   lcd_puts("yes!");    // line 2
  break;
  
  case 6:
   lcd_puts("Without a doubt!\n"); // line 1
   //lcd_puts("blank");   // line 2
  break;
  
  case 7:
   lcd_puts("Yes.\n"); // line 1
   //lcd_puts("blank");   // line 2
  break;
  
  case 8:
   lcd_puts("Yes, definitely\n"); // line 1
   //lcd_puts("blank");   // line 2
  break;
  
  case 9:
   lcd_puts("You may rely\n");  // line 1
   lcd_puts("on it!");    // line 2
  break;
  
  case 10:
   lcd_puts("Reply hazy,\n");  // line 1
   lcd_puts("try again.");   // line 2
  break;
  
  case 11:
   lcd_puts("Ask again later.\n"); // line 1
   //lcd_puts("blank");   // line 2
  break;
  
  case 12:
   lcd_puts("Better not tell\n"); // line 1
   lcd_puts("you now!");   // line 2
  break;
  
  case 13:
   lcd_puts("Cannot predict\n"); // line 1
   lcd_puts("now...");    // line 2
  break;
  
  case 14:
   lcd_puts("Concentrate and\n"); // line 1
   lcd_puts("ask again.");   // line 2
  break;
  
  case 15:
   lcd_puts("Don't count on\n"); // line 1
   lcd_puts("it!");    // line 2
  break;
  
  case 16:
   lcd_puts("My reply is no.\n"); // line 1
   //lcd_puts("blank");   // line 2
  break;
  
  case 17:
   lcd_puts("My sources say\n"); // line 1
   lcd_puts("no!");    // line 2
  break;
  
  case 18:
   lcd_puts("Outlook not so\n"); // line 1
   lcd_puts("good.");    // line 2
  break;
  
  case 19:
   lcd_puts("Very doubtful!\n"); // line 1
   lcd_puts("LOL");    // line 2
  break;
  
  default: // you should never be here
   lcd_puts("IDK\n");    // line 1
  
 }
 
  _delay_ms(5000); // display the answer for this long
    
 }
}


// functions

void setup(void)
{

// port config

DDRC |= ((1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5) | (1<<6)); // set PC0::6 to 1 for LCD OUTPUT

DDRD &= ~(1<<2);    // set PD0 to "0" for mercury switch input
PORTD |= (1<<2);    // enable internal pullup
DDRD |= ((1<<0) | (1<<1)); // set PD1 to "1" for output - LED PD0 for LCD
PORTD &= ~(1<<1);    // set the output low

// interrupt config
// external interrupts

EICRA |= ((1<<ISC00) | (1<<ISC01)); // external rising edge interrupt on INT0
EIMSK |= (1<<INT0);     // enable external interrupt

}

ISR(INT0_vect)
{
shake_count++;
}

int is_shakin(void)
{
// this function determines if the unit is being shaken based on the number
// of pin state changes in 100mS

 uint8_t shake_count_first = shake_count; // initial shake count
 
 _delay_ms(100);
 
 if (shake_count - shake_count_first > 3) // can adjust the shake "sensitivity" here
 {
  LED_PORT |= (1<<LED);
  return 1;
 }
 
 LED_PORT &= ~(1<<LED);

return 0;
}

Here is a video of the Magic 8 Thing in action. As you can see, you ask it a question (which I failed to do in the video), shake it and it replies with one of its 20 answers. If you shake it to hard though, it tells you to "Stop It!" then gives you an answer anyway. The sound at the end of the video is my cellphone getting a text message. It has nothing to do with the Magic 8 Thing.

So, as I stated in the beginning, this Magic 8 Thing was made to help me decide if I have goofed off enough and should start on the cell phone charger repair. When I posed the the question "Magic 8 thing, have I procrastinated long enough?" it replied with the text in the picture below. Apropos.

Cigar Box Laser Light Show

2011-03-11T18:25:00.007-05:00

It was spring break last week so I had some spare time to kill. I wanted to do a project that would be done fairly quickly and still have some time to study for classes resuming. I do have several other projects going that I could have worked on, but I figured a laser light show would be appropriate for the occasion, being spring break and all. Actually, I have no idea if spring break party goers are the least bit interested in seeing laser light shows, but I am interested in getting some motors spinning programmatically. And to seal the deal there is a new cat in the mix over here so I have buckets full of laser pointers.

A cigar box made a really nice case for this project due to the nature of mounting the motors. Initially I was going to use a Fossil watch tin but it proved too small for everything to fit nicely. Cigar shops sell empty boxes for a few dollars each.

Here is an overview of the theory of operation. When a mirror is mounted on a motor shaft so that the mirrors' face is less than perpendicular and less than parallel to the motors axis of rotation and a laser is reflected off of this rotating mirror, the reflected laser light will trace a circle on a projection surface and dependent on the speed of the motor being high enough, the laser path traced will appear to be a solid circle on the projection surface (a wall in my case) due to the persistence of vision. You can think about it like a laser cone being reflected off of the mirror. If you stopped there, with one motor and mirror, you would have a laser light show that can draw circles. If instead, you aim this reflected "laser cone" onto another one or more motor/mirror pairs, very interesting shapes begin to appear and change too, depending on the relative speed of all the motors.

I decided on 3 motors/mirrors for my laser light show. I got the motors with nice metal gears on their shafts from Ratshack. The gear was helpful in mounting the mirrors which are just hobby mirrors from some craft store. They are not first surface mirrors as you would have expected in an optics related project, but I did not witness any ghosting as I was anticipating. I think this is due to the relative brightness of the laser beam in a dark room.

I first mounted (epoxied) the mirrors onto the motor shaft at too large of an angle. I had carefully setup a jig that would hold a mirror at an angle and centered on the motor shaft to be glued. With the deviation of motor rotation axis and mirror surface too far from perpendicular the reflected laser cone just shot off the edges of the final mirror. In the end, I used a sharpie to mark the center of the mirror, squirted some hot glue on the back of the mirror and stuck the motor with gear on the center mark, holding it as near to perpendicular as my eyes could tell until the glue dried. This worked great and was much simpler than I had tried to make it.

After the project was complete, I projected circles onto a wall, one at a time with each mirror. I measured the diameter of the circle and the distance to the wall to empirically derive the angle of the mirror face to the motor's axis of rotation to be 87.55 degrees, 87.74 degrees and 86.12 degrees, for the first, second and third mirrors respectively.

Here you can see a laser being reflected through the three mirrors. And in the next photo how I set up the 3 motors/mirrors to be 45 degrees from each other. The laser beam "enters" the lower left mirror, reflected to the top left mirror then, on to the final mirror on the right and out, straight down, 90 degrees from where it started.

And here it is all set up ready to use. You can select manual mode where one of three potentiometers is assigned to one of the three motors to control its speed via PWM. The scale potentiometer scales the PWM output so that you can run the whole system at say 50% or 82% etc of full speed. In automatic mode a PRN generates the motors PWM values, it too is scaled by the scale pot. Also, in automatic mode the third motor potentiometer now controls the fade delay, setting how long it takes the motor to get to its new PWM value.

Here are a couple of videos. The first one shows the output while running in automatic mode. The second video is a slide show of photos of the output. There are more videos on my YouTube channel of the laser light show if you would like to have a look; these are just two.

A couple things I noticed about my setup are that one of the three motors whines at lower speeds. I fully expected the whole thing to be a little noisy, and to be fair in person it is not loud at all. I suspect the one motor has looser windings than the rest allowing them to vibrate more than the others. The PWM frequency I had to drive the motors at is well within the human audible range. I had initally tried a higher PWM frequency but could not get the motors to spin. I think this is an issue with motor inductance.

As you can imagine video and pictures of the laser light show have framerate issues that produce interesting effects but aren't that great to look at on youtube. In person, the laser is much brighter and it does produce some pretty interesting images. Some almost appear three dimensional. It was a fun project, but I doubt I will get that much use out of it. I certainly wont be sitting there staring at it for hours on end, but on the upside to that, if I look in a mirror I probably won't see my face melting off and flowing into a river that a unicorn is drinking from. Tune in, turn on, and drop out.

Code and circuit. On the circuit side of things there really isnt much to talk about. I included a description of the hardware in the comments in the program that has a bit more detail, but basically the ATMega328 reads a pot and outputs a PWM signal that triggers the gate of an IRF510 mosfet for each motor. The motors needed 3vDC so I whipped up a quick power supply with an LM317 and a heatsink. thats about it really.

And here is the code.

/*
Program Tile: Laser Light Show v1.0
Filename: ATMega_328_LLS_v1.0_main.c

Date: 2011.03.10

Author: Pete Mills
http://petemills.blogspot.com/

ATMega328
Int. RC Osc. 8 MHz; Start-up time PWRDWN/RESET: 6 CK/14 CK + 65 ms

*/

/*
Program Description

This program has two modes of operation.  In the manual mode, four potentiometers voltages
are measured. One for "scale" and 3 are assigned to 3 motors PWM channels. That is to say
an 8-bit pot value is read, it is scaled by the scale pot value and it is put into an 8-bit PWM 
register such that a potentiometer is controlling the speed of the motor via open loop PWM. 

The scale potentiometer sets the upper range for the PWM output. eg. if the scale pot is
at 50% the PWM output is scaled full range (0::255) to 0::127.

So, in manual mode, a pot is read, the value scaled based on the scale pot, the value
is output to a motor channel. This is done 3 times, once for each motor.

In automatic mode, the scale pot works in just the same way but, the 3 "motor pots" no
longer control the speed of the motors.  Instead rand() is called to generate an 8-bit
PRN that is then scaled by the scale pot and put into the PWM register for a motor.

In automatic mode the third motor pot (motor_pot_2 ADC CH2) is now used to set the fade delay 
between random speed generations.  Larger ADC values = slower fade times.

There is an LED connected to PD0 to indicate which mode you are in, though it is fairly
obvious when the laser light show is running itself using automatic mode.
*/

/*
Circuit description

Microcontroller: ATMega328

Regulated 5v power is supplied via an LM7805 and requisite caps
No external crystal as the internal R/C oscillator is used (dont for get to set the fuses...)
See above for internal R/C oscillator settings.


There are 4 potientiometers with their wipers connected to PC0::3 and legs to 5v and gnd
An led is connected to PD2 with a current limiting resistor
PD0 has a toggle switch to ground for selecting the mode
PD3, PD5 and PD6 connect to the gate of 3 separate IRF510 mosfets
The 3 IRF510 mosfets each have a 1k0 pulldown resistor attached to their gates.
The source of said mosfets are each connected to gnd and their drains to one leg of a motor,
the other leg of the motor connects to +3v motor power.
Across each of the motor leads is attached a reverse biased 1N4001 diode to protect against back EMF

The 3v motor power comes from an LM317 adjustable regulator with heatsink attached. 
*/

// Includes

#include <avr/io.h>     // defines things like "PORTB" and "TCCR0" etc
#include <util/delay.h>    // delay functions
#include <avr/interrupt.h>   // interrupt service
//#include <avr/sleep.h>


// Definitions

#define LED_PORT PORTD
#define LED PD2      // LED pin PORTD Pin 2
#define MODE PIND0     // mode switch

#define FIRST_ADC_INPUT 0   // lowest ADC channel to sample
#define ADC_CHANNELS 4    // number of ADC channels to sample
#define ADC_VREF_TYPE 0    // AREF, Internal Vref turned off

#define MOTOR_POT_0 0    // ADC channels
#define MOTOR_POT_1 1    
#define MOTOR_POT_2 2
#define SCALE_POT 3


// Global Constants

uint8_t FADE_DELAY_MIN = UINT8_C (10);  // mS
uint8_t IN_LOW_SCALE = UINT8_C (0);   // output scaling
uint8_t IN_HI_SCALE = UINT8_C (255);  // max val for motor pot ADC
uint8_t OUT_LOW_SCALE = UINT8_C (0);  // min val for motor pot ADC

volatile uint8_t adc_raw[ADC_CHANNELS];


// function prototypes

void setup(void);
int get_adc(int a);
int scale_outp(int input, int inp_low, int inp_hi, int outp_low, int outp_hi);
ISR(ADC_vect);


int main(void)
{



setup(); // do port configs etc
sei();  // global interrupt enable

 while(1)
 { 
 
  // Variables
  
  uint8_t cur_motor_speed_0 = 0;  // current speed of motor 0::255
  uint8_t cur_motor_speed_1 = 0;
  uint8_t cur_motor_speed_2 = 0;
  
  uint8_t new_motor_speed_0 = 0;  // random value to fade to 0::255
  uint8_t new_motor_speed_1 = 0;
  uint8_t new_motor_speed_2 = 0;
  
  uint8_t adc_val_motor_0 = 0;  // pot on adc0
  uint8_t adc_val_motor_1 = 0;  // pot on adc1
  uint8_t adc_val_motor_2 = 0;  // pot on adc2
  uint8_t adc_val_scale = 0;   // pot on adc3
  
  
  PORTD &= ~(1<<LED);  // turn off led to show where you are - manual mode
  
  // get the output scale value
  
  adc_val_scale = adc_raw[SCALE_POT];  
  
  
  // get the motor pot value, scale it and output to PWM channel - thrice
  
  adc_val_motor_0 = adc_raw[MOTOR_POT_0];  
  cur_motor_speed_0 = scale_outp(adc_val_motor_0, IN_LOW_SCALE, IN_HI_SCALE, OUT_LOW_SCALE, adc_val_scale);
  OCR2B = cur_motor_speed_0;
  
  adc_val_motor_1 = adc_raw[MOTOR_POT_1];
  cur_motor_speed_1 = scale_outp(adc_val_motor_1, IN_LOW_SCALE, IN_HI_SCALE, OUT_LOW_SCALE, adc_val_scale);
  OCR0B = cur_motor_speed_1;
  
  adc_val_motor_2 = adc_raw[MOTOR_POT_2];
  cur_motor_speed_2 = scale_outp(adc_val_motor_2, IN_LOW_SCALE, IN_HI_SCALE, OUT_LOW_SCALE, adc_val_scale);
  OCR0A = cur_motor_speed_2;
  
  _delay_ms(20); 
  
  // effective end of manual mode code
  
  
  while (PIND & (1<<MODE))     // if mode switch is on automatic mode (val 1/true)
  {
  
   PORTD |= (1<<LED);      // turn on led to show mode is automatic mode
  
   new_motor_speed_0 = (uint8_t) rand(); // get a pseudo random number from 0 to 255 for each of the motors
   new_motor_speed_1 = (uint8_t) rand();
   new_motor_speed_2 = (uint8_t) rand();
  
  
   // while the current motor speed != motor speed set point
   
   while((cur_motor_speed_0 + cur_motor_speed_1 + cur_motor_speed_2) != (new_motor_speed_0 + new_motor_speed_1 + new_motor_speed_2))
   {
    
    if(cur_motor_speed_0 > new_motor_speed_0){   // take a step towards the new speed for motor 0
    --cur_motor_speed_0;
    }
   
    else if(cur_motor_speed_0 < new_motor_speed_0){
    ++cur_motor_speed_0;
    }
   
   
    if(cur_motor_speed_1 > new_motor_speed_1){  // and for motor 1
    --cur_motor_speed_1;
    }
    
    else if(cur_motor_speed_1 < new_motor_speed_1){
    ++cur_motor_speed_1;
    }
   
   
    if(cur_motor_speed_2 > new_motor_speed_2){  // and motor 2
    --cur_motor_speed_2;
    }
   
    else if(cur_motor_speed_2 < new_motor_speed_2){
    ++cur_motor_speed_2;
    }
    
    
    adc_val_scale = adc_raw[SCALE_POT];  // get the scale pot value
    
    // scale values first then output to PWM registers
    
    OCR2B = scale_outp(cur_motor_speed_0, IN_LOW_SCALE, IN_HI_SCALE, OUT_LOW_SCALE, adc_val_scale);
    OCR0B = scale_outp(cur_motor_speed_1, IN_LOW_SCALE, IN_HI_SCALE, OUT_LOW_SCALE, adc_val_scale);
    OCR0A = scale_outp(cur_motor_speed_2, IN_LOW_SCALE, IN_HI_SCALE, OUT_LOW_SCALE, adc_val_scale);
   
   
    // MOTOR_POT_2 now controls the fade delay within automatic mode
    
    adc_val_motor_2 = adc_raw[MOTOR_POT_2];  
    _delay_ms(FADE_DELAY_MIN + adc_val_motor_2); 
    
   } // end fade while
  
  } // end if(MODE)
  
 } // end while(1)
  
} // end int main()


// functions

void setup(void)
{

// port config

DDRC &= ~((1<<0) | (1<<1) | (1<<2) | (1<<3));  // set PC0::3 to "0" for adc input

DDRD &= ~(1<<0);          // set PD0 to "0" for switch input
PORTD |= (1<<0);          // enable internal pullup
DDRD |= ((1<<2) | (1<<3) | (1<<5) | (1<<6));   // set PD2::3 and PD5::6 to "1" for output - PWM & LED
PORTD &= ~((1<<2) | (1<<3) | (1<<5) | (1<<6));  // set the outputs low

// ADC Config

// adc enable, cdiv 8Mhz/64 = 125kHz, interrupt enable, auto trigger enable

ADCSRA |= ((1<<ADEN) | (1<<ADPS2) | (1<<ADPS1) | (1<<ADIE) | (1<<ADATE));  
ADCSRB |= (1<<ADTS2); // set to be anything other than free running mode 
DIDR0 |=((1<<ADC0D) | (1<<ADC1D) | (1<<ADC2D) | (1<<ADC3D)); // disable digital input buffers to save power


// PWM config

// Timer/Counter0: channel:A/B clear on compare match, Fast PWM, TOP = OC0A,0C0B

TCCR0A |= ((1<<COM0A1) | (1<<COM0B1) | (1<<WGM01) | (1<<WGM00));
TCCR0B |= ((1<<CS00) | (1<<CS02));         // internal clock as source, div 1024 prescale

  
// Timer/Counter1: Channel:A clear on compare match, Fast PWM, TOP = OC2B

TCCR2A |= ((1<<COM2B1) | (1<<WGM21) | (1<<WGM20));
TCCR2B |= ((1<<CS20) | (1<<CS22));         // internal clock as source, div 1024 prescale

}

int scale_outp(int input, int inp_low, int inp_hi, int outp_low, int outp_hi)
{
return ((input - inp_low) * (outp_hi - outp_low) / (inp_hi - inp_low) + outp_low);
}

// ADC interrupt service routine
ISR(ADC_vect) 
{
static unsigned char input_index=0;

// Read the AD conversion result
   adc_raw[input_index]=ADCH;
// Select next ADC input
   if (++input_index >= ADC_CHANNELS)
      {
      input_index=0;
      }

   ADMUX=(FIRST_ADC_INPUT | ADC_VREF_TYPE | (1<<ADLAR))+input_index; //and left adjust

// Start the AD conversion
   ADCSRA |= (1<<ADSC);

}

UPDATE:

A reader asked if I would make a schematic available. I didn't have one so I just drew this one up from the text description in the program, of the circuit, that I wrote when I did the project.. This schematic was drawn after I built the circuit. I did not use this schematic while I was building this project, but I believe it to be correct.

New Workspace

2011-02-02T14:58:00.001-05:00

I am in the process of setting up a new workspace for my electronics/homework and thought I would share some photos of the progress. It is by no means complete but a good start has been made. This desk is really nice and big. It is 8 feet long and about 3 feet deep.

I like looking at pictures of workspaces because you can kind of see how they evolved over time to suit the individual. We make them work for us and what doesn't work doesn't usually last that long. It will be interesting to see what this work area looks like in a years time.

One of the things I would like to add in addition to more outlets is an outlet timer. Something that will automatically shut off my soldering station or hot glue gun when I accidentally leave them on. I guess I will have to remember to turn things off until I have more time to automate my life.

In this picture you can see a contact printer I am currently modifying to be used as a light box for PCB photofabrication, but I will post more about that another day.

I found a great Eck-Adams chair at Treasure Mart for $20. I think it matches the clock radio I found at Treasure Mart also, quite well. Here is a picture of the chair on the ride home.

Here are a couple of action shots. You can see that the chair functions quite well as something to sit on. Studies have shown that people who stand less often tend to sit more. I think this is a good addition to my workspace. It is really comfortable; it has that 1970's cushioning and it's seat to back angle is quite inviting.

Action Shot - Form following function

Action Shot - P.O.V.

It is no secret that this chair came from the Eck-Adams company. Googling the company turns up no real information though. I guess they have gone out of business. But, what a fine chair they made before they did.

Accidental photo's are interesting

If you have any photos of a workspace you would like to share, feel free to post a link in the comments. Or just share what the favorite part about your workspace is.

3$ LED Map Light Replacement

2011-01-01T02:43:00.005-05:00

I needed to replace the map light lamp in my car this afternoon and I thought I would go for LED replacement bulbs. The original incandescent bulb's orange glow looks dingy anyway and the last few times I needed to see by way of the map light it seemed rather dim. I figured the local auto parts store would be teeming with LED's as it seems all of the futuristic cars nowadays are jamb packed with the things. This, however, turned out not to be the case. According to the worker at the parts shop, LED's are "high performance" parts and as such, must be custom ordered. I was also told that "the internet has them". Neat. Too bad "the internet" thinks LED replacement bulbs are more valuable than McDonald's orange juice.

Not to be out done, I walked to the dollar store next door to the auto parts shop, where I found these beauties for 1$ each. A Trisonic 3 LED Push Light; batteries not included. I bought three, driver/passenger map light and cargo area hence, the $3. In case you were wondering, the text on the bottom front says "To uplift our character, begin with cultivating peace in mind, body, family, and activity.".

And on the back, the text "Cultivate a big heart-but a small ego", let me know these were the right bit of kit for the job because, that is exactly what I was trying to do. No, this project wasn't "X to the Z" pimping any rides. And, my car is neither empirically "faster" nor, objectively, more "furious" because of this upgrade. Just humble LED's helping electrons change orbitals to emit photons for me to read maps by.

I wanted to verify the light worked as intended and would be bright enough first, before ripping it to pieces.

This is what I found inside. 3 LED's, a switch and a single resistor.

And just what do we have here? The good people of Trisonic have designed their circuit to have the LED's in parallel. This works for the design specifications of the product they made but it is not helpful to me so I first desoldered all of the components. Then, I cut through two of the PCB traces to allow me to solder the LED's back in place in series instead of parallel.

Before

While the LED's were desoldered from the board I wired one of them up to a 9v battery through a 1k0 resistor. Measuring the voltage across the LED I got a forward voltage Vf=2.8v. Previously, I had measured the current of all three LED's together to be 130mA before taking this thing apart so, I know each LED can handle at least ~43mA. To select my current limiting resistor for the series LED's I have ((14vBatt-(2.8*3))/40mA = 140R or standard value 150R for 37mA. Power dissipation 0.207W so, a 1/4 Watt resistor is fine.

Here, Vbatt = 14v because the car's 12v system operates around 13v with the car running at idle and peaks up to ~14v when the RPM of the alternator increases. 14v is kind of a design for "worst case" scenario with lower battery voltages resulting in LED operation towards safer limits.

Here you can see the LED's soldered in the new series configuration and current limiting resistor in place. In series, the LED's are hooked up anode to cathode of each other with a current limiting resistor on one end, the negative side of 12v in my case.

After

Here you can see the LED PCB hot glued into place in the light reflector housing. You can also see the PCB traces I cut to allow the parallel/series modification. The +/- 12v (nominal) power leads on the LED board are soldered to the wires that used to deliver battery voltage to the incandescent bulb. The connector for the original lamp was left in place electrically and solder joints were insulated against short circuits.

A side by side comparison shows the difference in color of the LED's on the left and the incandescent bulb on the right. The LED's are equally as bright and diffuse quite well so there is no "hot spot" of light. I will perform the same LED retrofit to the right side of the light housing next.

This was a fun afternoon project and I am pleased with the results. Average prices for ready made LED replacement bulbs for this style holder seem to be $15 x 3 lights = $45. The method outlined above came in at ~$3 total.

Mannequin Leg Lamp

2010-10-25T17:13:00.001-04:00

The 1983 movie A Christmas Story supplied the idea for this project when I happened upon a ladies mannequin leg at a local store. To clarify, the leg was for sale and I did pay for it.

So, in the movie A Christmas Story the father is awarded a leg lamp for winning a contest. Technically, the winning answer is supplied by his wife and when the prize shows up she is less than enthusiastic about it. But, the father is quite smitten with the leg lamp and the movie takes place in the 1940's so it's all good.

Here, I have just found and purchased the leg. As you can see, I am quite happy with the find.

I took the leg shoe shopping. Although I didn't find any shoes there to fit I did get some good information. The ladies at the store, who got a good laugh out of shoe shopping for a mannequin leg, said I would need a size 6, 4" heel. I suspect it is closer to a 6" heel that would be necessary.

A local thrift store had these shoes available. Not a perfect match for the lamp in the movie or even a good match for the leg as it needs a higher heel but the size was right and so was the $3.60 price tag.

Halloween seems to be a good time to make one of these lamps as body parts and costume clothes are necessary ingredients. The stockings came from a seasonal Halloween shop. Sexay...

Here you can see the leg manufacture info it says RPM Industries, INC Shoe Form Division Auburn, NY. The designation #W-47 is probably the model number. You can also see that I have added a piece of poplar wood with a clearance hole for the lamp parts about to be installed.

With the parts from a donor lamp installed I could run the power cord. I drilled a clearance hole in the leg approximately in between the inferior extensor retinaculum would be if this were a human leg. Once threaded through the interior of the leg I tied a knot in the cord for strain relief. Then I wired the bulb socket so that the center conductor was the AC "hot" wire and the threaded part was the AC "neutral".

One of the things I was struggling with design wise was how to mount the leg in the shoe on a base so that it will stand up and not wobble around. I thought that a shoe like the one I found would be enough to strap it down and in the end it was ok, but I was a bit disappointed to find that the strap has a piece of elastic on it. So, as it stands now, I have screwed the sole of the shoe to the base and have a little riser temporarily to make up for the slightly short heel. The base of the lamp is a piece of locally reclaimed black walnut. For now it is unfinished but I will pretty it up one day.

The stockings are infuriatingly difficult to stuff in the end of the shoe against the slippery plastic mannequin leg. You can also see the local black walnut base here.

Here is the nearly finished product. As you can see it is not an exact replica of the one in the movie. For instance, my shade with the added tassels is a bit different and the leg in the movie was, um, meatier? But, differences aside, anyone who as seen it thus, far immediately recalls the movie A Christmas Story.

Hur, Hur...

This is by no means a project of great technical achievement, but it was a heck of a lot of fun to build. There is something to be said for spontaneous projects. I did not set out to build or own one of these lamps - or any lamp at the time, but I found the leg and had a few hours to kill.

In the movie the father uses the words "glorious" and "magnificent" to describe his lamp and if I am honest with myself, truer words could not describe this lamp. I find myself looking at it with satisfaction and sometimes turning it on just to have it on. The pictures, unfortunately, do not do it justice.

School Bell

2010-10-17T15:56:00.013-04:00

Having several irons in the fire has never stopped me from opening the door when opportunity comes knocking. Ok, so this school bell didn't exactly "find" me so much as I was out at one of my usual haunts Treasure Mart looking for neat treasures when I came across IT.

It was labeled "School Bell - $8.00" and that was it. It rattled when I shook it, which turned out to be a mounting screw, surplus to requirement, left inside. Despite the mysterious rattle and the rusted condition of the bell it was too good of a find to pass up.

As you can see here it is labeled "The Autocall Co.". It also says [0].22 Amps, 24 Watts and 115-60. The last designation I take to mean 115 volts at 60 Hertz aka standard US AC voltage/frequency.

Immediately after getting home I opened it up to discover the bell's simple design. A spring dampened plunger in an AC solenoid. Each half of that 60Hz sine wave causing the plunger to move to and fro; ringing out that familiar and much awaited signal that class was over. This time, however, there would be no "Pete, please see me after class.". Shenanigans will abound.

The bell came with two 14 Ga. wires, one stranded the other solid, attached to the solenoid. Testing the bell by jamming these wires into an outlet controlled by a wall switch proved that the bell works. Not a surprising revelation after the visual inspection. However, needless to say, jamming bare wires into an outlet is not a long term solution to powering this bell and they were removed in favor of a two prong plug which you can see in the above pictures.

This thing really is quite loud. The microphone on my camera cannot pick up the audio too well until the amplitude falls within range.

Now, I have several ideas on what I will do with this bell in the future but I imagine nothing just yet. I think the application will present itself when the time is right. Perhaps an alarm to alert you the refrigerator door has been left open for too long. An alarm clock? Maybe use a PIR sensor to trigger the bell for a couple seconds anytime it "sees" a person enter a room. Or it could ring each time an email comes into my inbox. Certainly this serves as another reminder that an inductive vehicle detector loop is desirable in everyone's driveway. And of course with Halloween just around the corner it could be used to just plain scare the living daylights out of some poor unsuspecting soul. Let me know in the comment section what you would do with a school bell of your own.

A brief word on safety. Although this is called a school bell I believe they are also used in fire alarm systems. If nothing else I believe some people might interpret the sound to mean "DANGER". With this in mind I only activate the bell where those that can hear it are aware that the sound is not intended to signal any type of emergency condition. I encourage you to consider this possibility if you happen to come across such an item to play with too.

Train Whistle Doorbell

2010-05-14T14:40:00.022-04:00

For the people who know me, the title of this project will be read as “well that sounds about right”. For the rest of society it may need some modicum of rationalization. To that end, have you ever missed the doorbell ringing? Perhaps you were in the shower or vacuuming the floor. Well, fear no more; you won't miss hearing this one.

I was given this Lunkenheimer steam train whistle as a birthday gift quite a few years ago. I came up with the idea to make it into a doorbell shortly thereafter for pretty obvious reasons, but I was unsure how I wanted to execute the wireless part of it. As you can see here I ended up using an el-cheapo wireless doorbell. This solved a lot of problems for me, not the least of which is that I can let the bell ring for a bit first before activating the steam whistle so my heart remains firmly in my chest rather than being startled to death every time UPS stops by.

Circuit wise, this doorbell came with an led on the front that blinks when the bell is activated. So, when I was designing the circuit in my head, thinking I would have to tap into the circuit board to get a logic signal; turns out I could just make a simple circuit to 'watch' the led; a photo transistor with a 10k pulldown works a treat. The sprinkler solenoid is rated at 24VAC. I don't know why they are AC and they work fine on DC, but it was easy enough to make a power supply that had the 24VAC and 12VDC so I did. The 5v RadioShack relay annoyed me when I found out it was going to draw 83mA and I would need a transistor amplifier. Yeah, not that big of a deal, but I thought I was being clever instead of using one of the 12v automotive relays from the junk box.

I took the spring and valve out of the steam whistle so that it could be operated solely by the sprinkler solenoid. This allows a massive amount of air to be passed through the whistle so “tuning” it was necessary by screwing the bell part in closer to the air escapement. I was hovering over the whistle when I tried out the circuit for the first time and it literally blasted the eye glasses off of my face.

Ear defenders are necessary.

The doorbell has, I think, 7 different rings to it. I settled on the “fog horn”; it cracks me up. It reminds me of Eeyore for whatever reason. Then the train whistle kicks in so it is like the whole thing goes from depressive to bat shit hyper in 3 seconds. For now it does a toot tooooot as you would imagine. It uses up pretty much all the air in the compressor in that short amount of time.

The video can be seen here; sadly the camera cannot pick up how loud it really is. The fact that the entire assembly wiggles when activated should give you a bit of an idea how much air is being passed through it though.

Here is another vid of the doorbell in action. The whistle is set inside of the house while I activate it from outside.

I am still trying to find a good way to upload code, but for today here it is:

http://www.scribd.com/doc/31385978

The schematic:

twdb_schematic