KB3VCQ Amateur Radio Musings

Here is the latest bottom of the board pic:

And the top of the board:

The receive section is done! And it works! I was able to hook it up and fire it up. Here is a shot of the waterfall using the Rocky SDR app in Windows:

Definitely hear lots of CW. The one problem I'm having right now is that (as you can see from the waterfall) I'm getting mirrored images, so the receiver's image rejection isn't working for some reason. The build manual has a section on dealing with it but I haven't gone through it yet. It could be a bad connection, or my limited knowledge of SDR software. I'll figure it out, but will postpone troubleshooting it until I've worked the rest of the stages to ensure that its not something that fixes itself once another stage is complete. But it's promising and it definitely works! Very cool.

Sent from Auteureist™ on iPad - http://auteureist.com/

Having built the SWL 40+ kit, I realized I didn't have a good way of determining frequencies short of using my big rig. The FreqMite seemed to fit the bill in that you could either build it into your rig or use it as a stand-alone unit. You can find more info about the kit here: http://smallwonderlabs.com/

The kit itself is a little bigger than a US quarter, the parts count is low, and there are no SMDs. The main components are a resistor array and the PIC microprocessor. The kit went together in about an hour or so.
I had originally wanted to build it into my SWL40+ but the SWL40+ is in a tin a bit bigger than an Altoids, but there still wasn't enough room or clearance for the FreqMite board. So I've settled on using the FreqMite in a standalone manner and put it and the 9v battery and a tiny speaker into an Altoids. I'll tap proper spots on the SWL40+ and route them to a jack on the enclosure. This will let me use the FreqMite on its own, but still easily plug into the SWL40+ for determining its frequency. The best of both worlds. The nice thing is, is that both kits come from Small Wonder Labs and the documentation of the FreqMite includes proper spots to tap into.
So here is the built FreqMite in its enclosure. The tiny magnetic speaker I salvaged from an old cordless phone set. It just sticks to the Altoids lid. The switch is the control for initiating a frequency check and programming a couple of the functions of the Pic. The jack will let me plug in some probes for testing kits, or an interconnect cable to another jack on a rig such as the SWL 40+ for a semi-permanent hookup.

The jumper array on the board below the resistor array is for programming the IF frequency of the rig and controlling how many digits to ouput if you plan on a permanent hookup.

Here is the closed FreqMite next to the SWL40+

The FreqMite is a nice solution and a lot cheaper than a full digital frequency counter.

I'm getting more confident with SDMs and the results are showing as I continue to use my painter's tape technique. Here is the bottom of the board. Note the multipin SMD (a dual flip-flo) that acts as the divider and the capacitor above it. They definitely look better than the other SMDs.

Here is the top of the board. Just two resistors in this section.

The next section is going to take a while. It's the RF input/output and switching circuitry. This looks like the section with the largest part count.

Updates as I progress.

The first thing I did when I got my Arduino Uno was get it to blink some basic Morse letters. Then I had to figure out how to get it to blink at different wpm rates. That was relatively easy once I figured out that 5 wpm is about a 240ms dit/dot or unit based on PARIS . Getting it to blink the complete Morse alphabet was a bit more difficult. I started with adding numbers. Then I ran into a problem. The Arduino would happily send KB3 of my code and then sit there looping over and over and over on the B3. Now, I'm familiar with programming in 'c' and there wasn't anything wrong with the code; this definitely smelled like a memory problem where the code runs into memory making it do strange things. I did some investigation and made a change and it worked! The problem is is that when you statically size character arrays they get stored in a certain (small) section of memory. If you declare the string arrays dynamically (using the [] operator) the arrays are loaded differently and keep the arrays from running into the code.

Anyway, it works. Mark Rogers, KC8GRQ gave me a hint on how to get a tone to play thru a speaker so I added some logic to either blink an LED or play thru the speaker. Here is a sample at 15wpm.

Memo.m4a

(download)

Click here to download:

Memo.m4a (209 KB)

The code should work with anything from 5wpm on up to where the dahs begin to sound like dits. Mark also wanted to see the code so here it is. The Arduino sketch:

/*
Morse blinker/sounder
Provided as is - KB3VCQ
*/

// Global variables

 

boolean done = false; // initialize a Boolean flag if we don't want to endlessly loop

#define LED 13
#define SPEAKER 6
#define TONE 600.0
#define USESPEAKER true

#define intracharacter 3 // delay between characters
#define dot 1 // length of a dit -- 1 unit
#define dash 3 // length of a dah
#define eow 7 // length at end of word
#define fiveWPM 240 // milliseconds for 5 wpm (based on sending PARIS 5 times for a total of 250 units)
#define wpm 15 // *** SET THIS TO YOUR DESIRED SPEED ***
#define speed fiveWPM / (wpm / 5) // multiplier to apply to 5 wpm rate. 2 = 10wpm, 2.5 = 15wmp, etc.

// *** SET THIS TO THE STRING YOU WANT TO SEND -- MUST BE UPPRCASE ***
char send[] = "THIS IS A TEST CQ DE KB3VCQ";

 

 

// Morse code tokens. 0 = dit, 1 = dah any other character will generate 8 dit error. 

// NOTE: These need to be in ASCII code sequence to work

char tokens [][7] = { "110011","100001", // ,,-
"010101","10010", // .,/
"11111","01111","00111","00011","00001","00000", // 0,1,2,3,4,5
"10000","11000","11100","11110", // 6,7,8,9
"111000","10101","<", // :,;,<
"=",">","001100", // =,>,?
"@", // @,
"01","1000","1010", // A,B,C
"100","0","0010", // D,E,F
"110","0000","00", // G,H,I
"0111","101","0100", // J,K,L
"11","10","111", // M,N,O
"0110","1101","010", // P,Q,R
"000","1","001", // S,T,U
"0001","011","1001", // V,W,X
"1011","1100" // Y,Z };

 

// Arduino setup routine
void setup()

{

pinMode(LED, OUTPUT); pinMode(SPEAKER,OUTPUT);
}

// Routine to output a dit
void dit()
{
if (USESPEAKER)
{
tone(SPEAKER,TONE, dot * speed);
delay(dot * speed); }
else
{
digitalWrite(LED, HIGH); // set the LED on
delay(dot * speed); // wait for a dot's worth
digitalWrite(LED, LOW); // set the LED off
}

delay(speed);
}

// Routine to output a dah
void dah()
{
if (USESPEAKER)
{
tone(SPEAKER,TONE, dash * speed);
delay(dash * speed);

}
else
{
digitalWrite(LED, HIGH); // set the LED on
delay(dash * speed); // wait for a dah's worth
digitalWrite(LED, LOW); // set the LED off
}
delay(speed);
}

// Intracharacter delay
void ic()
{
digitalWrite(LED, LOW); // set the LED off
delay (intracharacter * speed); // wait for a half second
}

// a space is 7 units of off based on speed
void spaceCharacter()
{
digitalWrite(LED, LOW); // set the LED off
delay((eow * speed) + (intracharacter * speed)); // wait for 7 units
}

// Send a CW error for unknown characters
void error()
{
for (int i = 0; i < 8; i++)
{
dit();
}
ic();
}

// Look up a character in the tokens array and send it
void send_element(int c)
{
char token_to_send[7]; // allocate space for the token
strcpy(token_to_send,tokens[c]); // copy the token from the table into our variable

int len = strlen(token_to_send); // figure out how many dit dahs are in it
for (int i = 0; i < len; i++) // for each item in the token
{
if (token_to_send[i] == '0') // if its a 0
{
dit(); // send a dit
}
else if (token_to_send[i] == '1')
{
dah(); // otherwise we send a dah
}
else
{
error(); // we don't have a valid morse token
}
}
ic(); // after each character there is an intercharacter delay
}

// The main send routine. Pull each character apart and determine its corresponding token.
void send_code()
{
int len = strlen(send); // get the length of the string to send
int c;

for (int i = 0; i < len; i++) // loop thru each character in the string to send
{
c = send[i]; // get the ASCII integer value of the character
if (c == ' ') // see if we are between words
{
spaceCharacter(); // send a space
}
else
{
c -= ','; // offset it by the lowest ASCII character in the tokens table (a comma)
send_element(c); // send that element from the token array

}

}
}

// The Arduino main run loop
void loop()

{
if (!done) // see if we are done the loop
{

send_code(); // send the string
spaceCharacter(); // make sure we have a space if we loop around to the beginning
done = true; // Uncomment to set our flag to finish sending
}
}

Feel free to use it.

MintDuino is an Altoids-tin (hence the mint) kit that lets you build an Arduino board. Normally when you get the Arduino its a complete board with all components populated. The MintDuino lets you build the actual board on a small breadboard. Here is the tin:

The tin has all the parts including a ATMega 328 processor, which is the heart of this Arduino, and a cool foldable breadboard (the power rails fold down to fit into the tin). The cool bit is also the bad bit, because the breadboard doesn't quite fit in the tin with the rails up, although you can use the sticky tape to mount it on the top or bottom. Getting it to fit would involve grinding down the corners a tiny bit, and I may try that.

The instructions can be found online at http://www.makershed.com/ProductDetails.asp?ProductCode=MSTIN3 under the HowTo tab.

It's a nice easy step by step process that I just started. Here is the breadboard with the 5v power supply under test:

The only other thing that would have been nice is if a schematic was provided so you could correlate what you're building with the circuit--I haven't found one on line. I'll keep you posted as I progress.

The little black one is the voltage regulator for the USB rail. The larger gold one is the programmable oscillator chip for the Softrock's local oscillator.

Sent from my iPhone