Technical Intercession

Working communications for the 90th running of the Pikes Peak International Hill Climb (PPIHC) made for a long day.   Arriving at 3AM to set-up, and finishing after 8PM, it proved taxing and rewarding.   The race was delayed 37 days due to the Waldo Canyon Fire (I worked emergency shelter communications during the fire), and was launched on August 12th.  A good review of the fastest (and longest) PPIHC ever, can be found here, with the course map.    “Ham” radio reporting spotters (Pikes Peak ARES members) were positioned at regular intervals along the race course; their purpose is to provide near real-time feedback on race progress and conditions.   Course preparation starts long before race day.   Repeaters must be installed and tested to be sure that all spotter locations have clear communications using VHF and/or UHF (144MHz or 440MHz) frequency bands.   Driving the course the day before yielded some amazing views (photo courtesy of Melissa Bishop):

On race day,  I settled my Jeep Wrangler safely above Gilley’s Corner, laid out the solar panels, fired up the radios, and performed communications checks on all primary & alternate frequencies:

Communications hardware was powered by an 80 Amp-Hour AGM battery running a pure sine wave inverter that everything was plugged into; providing the advantage of constant-voltage output, even as the battery discharged.   This turned out not to be a problem as the solar panels kept the battery over 13.1V while the sun was shining, and after sunset, it never dropped below 12.4V (but I did bring a spare battery).   12V equipment was run from a 110VAC to 13.8VDC switching power supply; some inefficiency, but again, constant output voltage.  All DC runs were terminated with Anderson Powerpoles (30, 45, & 75A) and fusing.

Here’s a  video of classic car racers taking the corner (I was reporting from the red Jeep). Mmm-mm can you smell the nitro?

The only severe crash closed the course for an hour or so; amazingly, no fatalities, but several folks tried to make off with pieces:

Late in the afternoon, a storm blew in which caused the finish line to be moved down the mountain.   The storm caused a repeater to fail intermittently due to high-voltage induction on the antenna; this was a shocking (but not lethal) discovery made by one of the hams resetting the repeater.   Subsequent investigation uncovered a faulty ground connection.

After deploying for the Springer fire, arson investigation, and the Waldo Canyon fires, I have a few days to get ready for the Pikes Peak International Hill Climb (delayed due to fire).    Getting up on the mountain at 3AM, and not being finished until 7PM, it makes for a long day, especially on the remote power system (batteries).   As such, I decided to spruce up the radio & power equipment with Anderson Powerpole connectors; so I ordered a bunch of connectors, crimper, and cables from Quicksilver radio.  For the battery runs, I decided to use #6 cable and 75 amp Powerpoles to feed a pure sine-wave inverter.   What arrived was 30 feet of #8 red/black zip cord.   Unfortunately,  I didn’t notice the discrepancy until I had already cut-off 3 feet of cord.  The next (business) day, I called John at Quicksilver radio, and explained the situation. He promptly told me to keep the #8, and the #6 would ship out that day.

Great customer service, thanks Quicksilver!

NOTE:  ARES and RACES use the same configuration for Powerpole assembly.  This assures that all equipment using Powerpoles will interconnect.    The 15, 30, and 45 amp housings are identical, and will interconnect.  The 75 amp connectors are physically larger, and will only fit with other 75 amp connectors.   The same convention “red to right, tab on top” is followed when connectors are viewed from the front (contact) side.

The latest issue of QEX (March/April) came this week with an article about an open-source keyer (pages 25-31).   This article referenced an earlier QEX article from Sept/Oct 2009 using an Arduino.    Since I have a Bencher paddle lying around, but no practice oscillator, I decided to investigate a bit further.   An Iambic keyer needs logic for creating its output, so the Arduino seemed like a shoe-in, especially since they’re widely available, even through Radio Shack (SparkFun, and AdaFruit are other good suppliers).

Finding back-issue articles of QEX turned out to be nigh impossible, so a few quick searches on the ‘net  turned up programs that could be easily adapted.   The first was a tone generation tutorial.   The next was a simple, but functional program that signalled through the LED.  I trimmed the fluff from this program and added tonal output (source code below). Here’s what the basic parts look like:

Plus the paddle (of course).  The two 4.7K resistors on the 1/8″ jack are pull-up resistors and the paddle “shorts” them to ground when contact is made.  Note the 100 ohm resistor in series with the speaker.   Some folks have used speakers from “singing” greeting cards. Wired-up, the completed simple keyer looks like:

The speaker is wired between digital pin 4 and ground.  The paddle wires connect to pins 2 and 5.  The red and black wires to the 1/8″ connector (resistors, barrel) are +5V and ground (respectively).

The code to run is as follows (download the Arduino software here):

///////////////////////////////////////////////////////////////////////////////
//
//  Iambic Morse Code Keyer Sketch
//  Copyright (c) 2009 Steven T. Elliott
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2.1 of the License, or (at your option) any later version.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Lesser General Public License for more details:
//
//  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
//  Boston, MA  02111-1307  USA
//
//  http://openqrp.org/?p=343
//
//  "Trimmed" by Bill Bishop - wrb[at]wrbishop.com
//
///////////////////////////////////////////////////////////////////////////////
//
//                         openQRP CPU Pin Definitions
//
///////////////////////////////////////////////////////////////////////////////
//
// Digital Pins
//
int         tonePin  = 4;       // Tone output pin
int         LPin     = 5;       // Left paddle input
int         RPin     = 2;       // Right paddle input
int         ledPin   = 13;      //
//
////////////////////////////////////////////////////////////////////////////////
//
//  keyerControl bit definitions
//
#define     DIT_L      0x01     // Dit latch
#define     DAH_L      0x02     // Dah latch
#define     DIT_PROC   0x04     // Dit is being processed
#define     PDLSWAP    0x08     // 0 for normal, 1 for swap
#define     IAMBICB    0x10     // 0 for Iambic A, 1 for Iambic B
//
////////////////////////////////////////////////////////////////////////////////
//
//  Library Instantiations
//
////////////////////////////////////////////////////////////////////////////////
//
///////////////////////////////////////////////////////////////////////////////
//
//  Global Variables
//

unsigned long       ditTime;                    // No. milliseconds per dit
unsigned char       keyerControl;
unsigned char       keyerState;

#define NOTE_D5  587	// "pitch.h" at http://arduino.cc/en/Tutorial/Tone

///////////////////////////////////////////////////////////////////////////////
//
//  State Machine Defines

enum KSTYPE {IDLE, CHK_DIT, CHK_DAH, KEYED_PREP, KEYED, INTER_ELEMENT };

///////////////////////////////////////////////////////////////////////////////
//
//  System Initialization
//
///////////////////////////////////////////////////////////////////////////////

void setup() {

    // Setup outputs
    pinMode(ledPin, OUTPUT);      // sets the digital pin as output

    // Setup control input pins
    pinMode(LPin, INPUT);        // sets Left Paddle digital pin as input
    pinMode(RPin, INPUT);        // sets Right Paddle digital pin as input
    digitalWrite(ledPin, LOW);   // turn the LED off

    keyerState = IDLE;
    keyerControl = IAMBICB;      // Or 0 for IAMBICA
    loadWPM(15);                 // Fix speed at 15 WPM
}

///////////////////////////////////////////////////////////////////////////////
//
//  Main Work Loop
//
///////////////////////////////////////////////////////////////////////////////

void loop()
{
  static long ktimer;
  int debounce;

  // Basic Iambic Keyer
  // keyerControl contains processing flags and keyer mode bits
  // Supports Iambic A and B
  // State machine based, uses calls to millis() for timing.

  switch (keyerState) {
    case IDLE:
        // Wait for direct or latched paddle press
        if ((digitalRead(LPin) == LOW) ||
                (digitalRead(RPin) == LOW) ||
                    (keyerControl & 0x03)) {
            update_PaddleLatch();
            keyerState = CHK_DIT;
        }
        break;

    case CHK_DIT:
        // See if the dit paddle was pressed
        if (keyerControl & DIT_L) {
            keyerControl |= DIT_PROC;
            ktimer = ditTime;
            keyerState = KEYED_PREP;
        }
        else {
            keyerState = CHK_DAH;
        }
        break;

    case CHK_DAH:
        // See if dah paddle was pressed
        if (keyerControl & DAH_L) {
            ktimer = ditTime*3;
            keyerState = KEYED_PREP;
        }
        else {
            keyerState = IDLE;
        }
        break;

    case KEYED_PREP:
        // Assert key down, start timing, state shared for dit or dah
        digitalWrite(ledPin, HIGH);         // turn the LED on
        tone( tonePin, NOTE_D5 );
        ktimer += millis();                 // set ktimer to interval end time
        keyerControl &= ~(DIT_L + DAH_L);   // clear both paddle latch bits
        keyerState = KEYED;                 // next state
        break;

    case KEYED:
        // Wait for timer to expire
        if (millis() > ktimer) {            // are we at end of key down ?
            digitalWrite(ledPin, LOW);      // turn the LED off
            noTone( tonePin );
            ktimer = millis() + ditTime;    // inter-element time
            keyerState = INTER_ELEMENT;     // next state
        }
        else if (keyerControl & IAMBICB) {
            update_PaddleLatch();           // early paddle latch in Iambic B mode
        }
        break;

    case INTER_ELEMENT:
        // Insert time between dits/dahs
        update_PaddleLatch();               // latch paddle state
        if (millis() > ktimer) {            // are we at end of inter-space ?
            if (keyerControl & DIT_PROC) {             // was it a dit or dah ?
                keyerControl &= ~(DIT_L + DIT_PROC);   // clear two bits
                keyerState = CHK_DAH;                  // dit done, check for dah
            }
            else {
                keyerControl &= ~(DAH_L);              // clear dah latch
                keyerState = IDLE;                     // go idle
            }
        }
        break;
    }
}

///////////////////////////////////////////////////////////////////////////////
//
//    Latch dit and/or dah press
//
//    Called by keyer routine
//
///////////////////////////////////////////////////////////////////////////////

void update_PaddleLatch()
{
    if (digitalRead(RPin) == LOW) {
        keyerControl |= DIT_L;
    }
    if (digitalRead(LPin) == LOW) {
        keyerControl |= DAH_L;
    }
}

///////////////////////////////////////////////////////////////////////////////
//
//    Calculate new time constants based on wpm value
//
///////////////////////////////////////////////////////////////////////////////

void loadWPM (int wpm)
{
    ditTime = 1200/wpm;
}

This keyer program has few options which must be configured at compile-time.   This isn’t always convenient.  So, while gratifying, I still desired more functionality.   But, before I dug in adding features, I did a few more searches and found this absolutely brilliant project:

http://radioartisan.wordpress.com/arduino-cw-keyer/

It has tons of features (including memories) and can be implemented by adding a few more wires and components.   Most of the features are accessible by simply adding a push-button switch, which allows commands to be specified via the paddle. I chose to add a 10K ohm potentiometer, and enable remote speed control by un-commenting the line:

//#define FEATURE_POTENTIOMETER

Which has the keyer looking like:

Adding switching outputs and even a PS2 keyboard are among the many features.   Take some time to look around the site, there are many hidden treasures.   As K3NG points out, enabling many of the features at-once may cause “memory overflow” on the ATMega328P.   It’s been my experience that simply moving to the Arudino Mega 2560, with its larger memory space,  resolves this issue.      Don’t get discouraged waiting for the compile & download to the Arduino; it took about 1 and 1/2 minutes (small sketches take only seconds).

NOTE: that you don’t need to use an entire Arduino module to execute on a project.   Once the project is working, you can pop-out the Atmel chip from the Arduino (usually a ATMega328P) and wire directly up to the pins on a perf or proto-board (or an Evil Mad Scientist Target board).   The chips themselves are only four bucks and some change.   Be sure to buy ones that have the boot loader already installed, or else you’ll need to buy a separate programmer.   See this article for more details and clock parts.

Wrapping up, the project needs boxed & painted, more switches & potentiometers added,  and a power supply.   What did I end up doing?  I put the word out to the local radio artisans, and picked up a used MFJ-492X for a good price.

Additional Links:

Using an Iambic Paddle.
Keyers, Paddles, & More.
Voice & Morse Keyers.