HF with a cheap SDR Dongle

Using an Arduino controlled Si5351 PLL Clock Module, Mixer, and a cheap RTL-SDR Dongle I tuned in on the 40 meter ham band today using the SDR # software













I came across a Mini-Circuit ZAD-1 double balanced mixer (DBM) at the TRW swap meet this weekend in good condition for 7 bucks so I grabbed it. This DBM with BNC connectors turned out to be a standard Level 7 mixer.



I connected my RTL-SDR dongle to the IF port with several adapters and fed the output of the Si5351 directly into the LO port. The antenna is connect to the RF port.



Using NT7S Arduino Library and a Mega 2560 board I set the clock0 to 125 Mhz to feed the LO. Below is the basic setup.



This set-up worked great for the Medium Wave (MW) AM broadcast band too. On 40 Meters I listen to several SSB stations just fine. Using the NT7S library for 125 Mhz may be a bit out of range since I do seem to hear a warble to the clock when I listen to the 125 Mhz signal directly on another receiver. I need to experiment with the original Adafruit library and see if there is a difference. All and all a cool experiment. If I can get the warble out of the clock and maybe add some band-pass filters this could be a very usable SDR receiver for HF.

Computer Build

I am building a custom game PC based on the Gigabyte GA-Z97X-UD3H motherboard. It needs to be ready by Christmas Day, and I still have a lot to do before it is finished.

Desert Farm

This weekend I was back in Arizona at my buddies farm. We had a great time playing with all his farm machines and seeing what new things he is working on, like this pump system. He calls it "FrankinPump". This is 4 gas powered pumps connected in parallel that can empty his 50000 gallon water tank in 2 hours.



We enjoyed the trip and his solar system worked perfectly with plenty of power even with the short winter days.

Fix or Replace?

I have a 4 to 5 year old Samsung LCD Monitor that developed an issue where after a 20 minute warm up the monitor would go black. If you cycled the power switch it would come back for two seconds then go black again. I did some quick research and found that a frequent issue is with the capacitors in the switching power supply.















I felt that the effort would be worth my time, so I replaced all the capacitors after a fairly lengthy dis-assembly process and then reconnected everything without fully assembling it and re-tested it. Unfortunately the problem remained. I continued the research now after spending nearly a full day on the project and determined after some lengthy tests that the fault is in the back lighting system. The back lights on this monitor are compact florescent (CFL) units. To replace the CFL is not as simple however. These units are attached to the panel assembly on each end and there are two tubes in each. I think many hams and electronic tinkers hate to throw away hardware if it can be repaired and I have gone to great lengths on other items in the past to get it done, but sometimes you just need to call it quits, or it will consume all your time. I wish things were made to be repaired however many are not or the parts costs exceed its value.

So in this case I will be parting it out to the junk box. There are many good parts and who knows they may live again.

GKOS Keyboard Mockup

I spent some time this week mocking up the GKOS keyboard using some clay. I have the Cherry MX "Black" switches now and will need to make PCBs for each set of  the three switch groups. The mock up taught me that I need some thickness between the fingers and thumbs for it to feel natural and comfortable. Another discovery is that I believe I build can build this using aluminum "L" channel and PCB material to bolt it together. I may even be able to make it folding!

QRSS with Si5351

As I mentioned in my previous post, I have been experimenting with the Adafruit Si5351A Breakout Board and today I thought I would do some frequency stability tests using the QRSS tool Spectran. This tool will enable me to see variation in frequency with sub-hertz resolution.

Using the NT7S Library I setup the following in the loop() section of the Arduino code

Code Snippet

As you can see, all I am doing is setting the frequency to 7.083.000 Mhz (in the 40 Meter band), then after 10 seconds, I set the frequency to 7.083.001 Mhz which is just 1 Hz higher for 5 seconds and repeat. The plot below using Spectran is showing the clock board being received by my FT-817 transceiver with my dipole antenna. The bread board was in the house about 20-30 feet from the antenna with just a 4 inch piece of wire as it's antenna. From left to right, I had been running it for over 10 minutes then I powered it down for about 2 minutes and then powered it back up. When it powered up again, it was about 5 Hz higher than before being shutdown, then after about 5 minutes it was back to where it was before I powered down (pretty cool!). The full width of the plot is 10 minutes and shows less than a 1 Hz variation over that period (again, very cool!).

I would say that this board with a bare Arduino chip would be a great option for a QRSS beacon module as well as the other uses we have discussed. The more I use the Si5351, the more I like it.

Si5351 Clock Module

I ordered a couple of the Adafruit Si5351 Clock Modules that arrived this week, and quickly soldered up the header and plugged it into a breadboard.




I first tried the Adafruit library and verified its ability to generate multiple output clocks, however it is a bit crude compared the NT7S Library. To use his Library I did find I needed to use the latest Arduino IDE for his example sketch to compile. After that it was very easy to generate any frequency in the HF range.

This module will be useful in many projects. People are using them in place of the standard DDS modules. In fact M0XPD as released an awesome dual VFO sketch with LCD display and rotary encoder.

GKOS Keyboard for Arduino

I built up a 6 switch keypad for use with the Arduino GKOS keyboard Library . I used small surface mount switches and super glued them to a PCB with a three foot ribbon cable.




This worked OK but it is hard to do key presses with more than 3 key chords with these switches. I will need to rebuild the keyboard using something like Cherry mechanical keyboard switches. With the minimal practice I have had with GKOS it seems like it is learn-able and usable with the help of a keyboard layout graphic. I would place this graphic on the side of the keyboard facing the user.

The Arduino Library provided by the Gkos_library is excellent and implements the full GKOS chord set. I did have a few issues getting it up and running and needed to make some quick updates to the library and the example code since it was developed a few years back. Here is the modified example code I used:

1:  /* Test your Gkos with the Serial Monitor of the Arduino IDE  
2:  This is a simple test to check that your GKOS keypad is  
3:  working, by showing on serial monitor the text you type.  
4:  */  
5:  #include <Gkos.h>  
6:   char* gEntry = "";   
7:  // Initialize Gkos library with pin numbers for keys A to F.  
8:  // Digital pins 14...19 are the same as analog pins 0...5  
9:   Gkos gkos(14, 15, 16, 17, 18, 19);  
10:  void setup(){  
11:   Serial.begin(9600); // Set up Serial library at 9600 bps.  
12:   // Use the Arduino SDE Serial Monitor to view the output!   
13:  }  
14:  void loop(){  
15:   gEntry = gkos.entry(); // Will return empty immediately if no entry  
16:   if (gEntry != 0){gPrint();}  
17:   // Add your other code here  
18:  }  
19:  void gPrint(){ // Convert commands depending on your application  
20:   if (strcmp(gEntry, "_Enter") == 0){  
21:     //Serial.println("");  
22:     Serial.write(10); Serial.write(13); return;  
23:   }  
24:   if (strcmp(gEntry, "_BS") == 0){  
25:     Serial.write(8); return;  
26:   }  
27:   if (strcmp(gEntry, "_Del") == 0){  
28:     Serial.write(127); return;  
29:   }  
30:   if (strcmp(gEntry, "_Tab") == 0){  
31:     Serial.write(9); return;  
32:   }  
33:   // Default   
34:   Serial.print(gEntry);  
35:  }  

Here is a link to the modified Library files to replace the existing ones:

Modified Library Files

The next step is to built a better keyboard and perhaps make it a little ergonomic. I am thinking of something in the shape of a standard game pad with the three switches on each side of the wedge operated by your index, middle, and ring fingers.

Arduino Hellschreiber Keyboard

I am looking at keyboard options to use with the Arduino Hellschreiber communicator. I would like something small and portable. There are mini QWERTY keyboards out there, however the Arduino will not support a USB keyboard directly. If the keyboard is downward comparable with the PS2 standard there is library to support that method. The PS2 library is large and will take up most of the Arduino memory though. This made me look at alternate keyboard designs. The alternate designs I have reviewed have significantly fewer keys than the familiar QWERTY keyboard. These methods are mostly based on a Chorded Keyboard. You have fewer keys but you need to press multiple keys at once to produce the different characters. I have now reviewed several of these methods using a very nice application called Autohotkey which is open source and free. Using this application and user submitted scripts I have tried out the following methods:

• T9 - Text on a numeric pad like the old cellphone method
• Frogpad (like) - A reduced size one handed method
• Thumbscript - Another numeric pad method
• ASETIOP - A two handed 10 key method
• Braille - A two handed 8 key method
• 7KAT - A 7 Key Alternate Typing method

Some of the above could not be fully tested due to limitations of my keyboard. Not all keyboards can support pressing 4 or more keys at the same time.

The last method evaluated was GKOS. I could not find a Autohotkey script for it but one could be adapted from the Braille script, however it does require up to 6 keys to be presses at the same time so it would be limited with my keyboard. There is also a program EXE available from the GKOS site that fully implements the method using either keys on your keyboard or the numeric pad that I did experiment with to better understand GKOS. In addition the site also has links to building your own keyboard using 6 switches and an Arduino library!

Since there is an Arduino library, I plan to wire up a 6 key pad and fully test it. This 6 key method seems neat, however it will depend on how quickly it can be learned and if I can obtain a decent typing speed.

I like the idea of this minimal 6 key pad to use on a portable system but it still may not be practical and I will fall back to either a PS2 keyboard or a QWERTY keyboard built from discrete buttons and shift resisters using the Arduino function ShiftIn.

Arduino Hellschreiber II

I modified the input circuit of my Hellschreiber Arduino project so I could feed it directly with audio from a receiver or other source. I replaced the electret mic with a 600:600 ohm isolation transformer. Yesterday (Saturday 10-18-2014) I recorded some of the Hellschreiber Sprint (2014-sprints) and the video below is a part of a QSO between Lou W8LEW and Bill WD9EQD before the contest on 20 meters. I recorded it using the WebSDR network and K2SDR receiver(s) in New Jersey.

Below is the complete circuit to feed the receiver audio into the Arduino for display. I am using three of the analog ports. One for the signal and two for pots to adjust the contrast of the signal on the display. Perhaps others will have better ideas of dealing with display adjustments and image processing. The cool thing is that Hellschreiber can be generated by a simple QRP CW transmitter and with the Arduino display and a simple direct conversion receiver, a portable Hellschrieber rig could be built. I am also thinking about a software based squelch that will pause the display when there is not a valid Hellschreiber signal present. This could be cool for beacons or short messages since the display holds over 2 minutes of receive output. You could then review transmissions that occurred hours ago.



Here is the code I am using currently. You will need to get the Seed 1.0 TFT library setup first and I suggest testing the display with the example code provided from Seed before trying my code. 73

 // Seven Line Hellscriber Painter  
   
 #include <stdint.h>  
 #include <TFT.h>  
   
 int analogPin = 5; // The audio input pin  
 int analogPot1 = 4; // Lower Limit Pot pin  
 int analogPot2 = 3; // Upper Limit Pot pin  
   
   
 int x, y, x2; // plotting varables  
 int sig = 0; // Audio signal varable   
 int pot1, pot2; // Analog pot values   
 int greendot, dot; // The Hellscrieber dot varables  
 int lower, upper; // Contrast mapped pot values  
   
   
   
   
 void setup()  
 {  
   
 Tft.init(); //init TFT library  
   
 }  
   
 void loop()  
 {  
  // Each Line is 28 pixels high  
  for (int y=0; y<320; y++)  
  {  
  for (int x=215-x2; x<229-x2; x++)  
  {  
   sig=analogRead(analogPin); // signal input  
   pot1=analogRead(analogPot1); //get lower limit  
   pot2=analogRead(analogPot2); //get upper limit  
     
   lower=map(pot1,0,1023,0,511); // map pot1 to lower range  
   upper=map(pot2,0,1023,512,1023); // map pot2 to upper range  
     
   dot=map(sig,lower,upper,0,63); // Signal mapped into 5 bits with a lower & upper limit for contrast  
     
   greendot= dot << 5; // shift the dot value into the green range of the display RGB 565  
     
   Tft.setPixel(x, y, greendot); // plot green dot  
   Tft.setPixel(x+13 ,y ,greendot); // plot sample green dot again shifted by 14 pixels  
     
   delayMicroseconds(3480L); // master time delay for Hellschreiber  
   
  }  
  }  
  x2=x2+35; // paint line offset with boundary to seperate each line with black space  
  if(x2>210) x2=0; // if seventh line, start at the top again  
 }  
   

Arduino Hellschreiber

I have had the idea for a while about whether one of the Color TFT displays for an Arduino could display Hellschreiber. Well I got some encouraging initial results when I attempted it on one of these displays.






A friend had told me about these displays that Radio Shack is closing out in their stores now. They are the Seeed 1.0 2.8 inch TFT displays selling for around 15 bucks! The newer models else where are 35 bucks.






Since it is a shield that plugs directly on top of the Arduino Uno I had to "tether it" via jumper wires so I could access the analog ports.






The display does use some of the analog ports if you want to use the touch screen part, but there is two unused ports even if you do, I left them all unconnected with my tether.

I constructed the following 2N3904 circuit with an electret mic to acoustically couple the Hellschreiber signals for my initial tests.






I am still working on the code and trying to develop some simple image processing methods to make it easier to use, but I have a long "to do" list.

1.) Modify the input circuit with an isolation transformer for direct connection to receiver/transceiver (e.g. PFR-3A).
2.) Code the contrast image controls in software
3.) Code the transmit Hellschrieber
4.) Build a keying circuit interface
5.) Build a shield that plugs between the Arduino and the Display to make it a clean package.

The idea is to have a small standalone Hellschrieber terminal that can connect to any standard CW transceiver. The Arduino makes this a nearly instant "on" system requiring no computer and ready for portable or field use.

Audio Interface

I am building up the KF5INZ computer audio interface and placing it in an enclosure. The kit is less the 10 bucks from eBay, with enclosure parts from TRW swapmeet, total cost under $20.

220 MHz Ground Plane Mounted

The 220 MHz ground plane is now mounted on the roof.

220 MHz Ground Plane II

I finished painting and weatherizing the ground plane. Here is it painted black.



You can see the clamping method using a hose clamp on the PVC pipe with slots every 90 degrees, here is a close up.



The PL259 connector will be wrapped with tape when installed to completely protect it from moisture.

220 Mhz Ground Plane Antenna

I will be needing a dedicated 220 MHz antenna for an upcoming project and needed it to be small. I had built a nice 220 Mhz J-pole that turned out being to large and the "home congress" rejected it's installation. A quarter wave ground plane is nice and small so it can be made "stealth". I had build other SO-239 connector antennas before, in fact one of my first antenna for 2 meters was one of this type and I soldered all of it and just used 12 AWG bare solid wire. It worked out great, but one drawback of the solid copper wire it that it not that stiff and if the wind blows hard for several days your antenna will get deformed and you will need to straighten it. I had always heard of people building them with welding rods (much stiffer than copper wire). A quick search on the internet yielded that basic dimensions AI4JI's website for a 220 Mhz antenna and I began work.  

I had these BernzOmatic rods that I got with a little torch years ago and there were 5 rods in the package. This is the perfect number however each rod is only 12 inches long. Before using these rods the flux was removed. The easiest way is to just take a hammer and gently pound on the rod until it crumbles off, then sand it clean  with sand paper.

The solution to the short rods was solved by using 2 inch lengths of 1/4 inch copper pipe. This is the soft copper tubing you use for connecting a ice maker to your frig. As you can see, I flatten part if it so I can make the radials 13.4 inches long.

The flatten section also allows an easy way to bend the radials at the required 45 degree angle.

For the radiator or vertical element, I just used a ring lug to extend it's length and it add safety by not being so pointed.

Here is the completed antenna before being painted. The antenna drops into a 3/4 inch PVC pipe that has been split on the ends so a house clamp will hold the antenna firmly in place. After the paint dries I will post more pictures and the mounting arrangement. The SWR was below 1.3:1 across the whole band.

Ferrite Core Memory

I read Mark's blog posting on Brainwagon about rope core memory and it's relation to the Apollo program with great interest, I have always been a fan if this tech. I also found another great posting on Wayne's blog HERE searching for other core memory stuff.

I set out to duplicate Wayne's work but tried to do it with only off the shelf modules and really no circuit building. I did want to step it up a little so I did build a 4-bit core memory unit.

I obtained my cores just as Wayne did, from eBay. It took a few weeks for the cores to ship but they came in a very small package from Bulgaria. The extra URLs that Mark provided in his posting gave me the pattern for my 4-bit core array. I used a proto board PCB to make a tiny breakout  assembly with header pins to allow me to plug it into a standard breadboard. My idea is to use a standard L298N motor controller board instead of building a driver circuit from scratch like Wayne.

The L298N boards are very available and I use them to drive both relays and motors. For the 4-bit array you would just need two of these boards. Here is the basic hook-up with two boards. Note; You will need a load resistor in each motor line (4 total) to limit the current, I use a 10 ohm resistor with 5 volts just like Wayne.

I lashed up a single L298N board to one core initially to see if it would work and I pretty much duplicated Wayne's results.

I am pulsing to the core three times just as Wayne did, first to set it to a "1" then followed by two pulses writing it to "0". On the scope I am displaying the three sync pulses (top trace) and the output of the sense wire (bottom trace), note the noise too. The sync pulse line is separate from the drive lines to be used with the scope, in the code this is PIN 12. The sync is just for the scope to use since the drive lines change polarity making the display not as clean. 

You can see I get the "kickback" on the "0" to "1" transition (first pulse) and then the "1" to "0" (second pulse), but not the "0" to "0" transition. My sense signal had an amplitude of about 50 mV with a 1 microsecond pulse length. The X/Y core pulses are about 8 microseconds long and the "kickback" occurs at about 6 microseconds from the leading edge, this would be the window to look for the read data to avoid the noise that you can see on trace two.

So with just a basic Arduino UNO and a L298N motor control board you can build Wayne's 1-bit wonder. You do also need a 10 ohm resistor in each motor line and a separate 5 volt power supply that can deliver at least 1 Amp but that is it!

I am not sure if I will expand mine to use the full 4-bits of the array and/or build a sense amplifier to read the data but it was fun to experiment with this piece of computer history. Here is my code for my 1-bit wonder, enjoy!

 /* Core Memory Experiment  
   
 Core Memory experiment using a L298N H-Bridge motor interface  
   
 Single Bit Core  
   
 Set the Core to "1" state then "0" state then "0" and repeat at the cycleDelay rate  
   
 */  
 int pin8 = 8;  
 int pin9 = 9;  
 int pin10 = 10;  
 int pin11 = 11;  
 int pin12 = 12;  
   
 int cycleDelay = 150;  
   
 // the setup routine runs once when you press reset:  
 void setup() {          
  // initialize the digital pin as an output for motor controler  
  pinMode(pin8, OUTPUT);   
  pinMode(pin9, OUTPUT);   
  pinMode(pin10, OUTPUT);   
  pinMode(pin11, OUTPUT);   
  pinMode(pin12, OUTPUT);   
 }  
   
 // Loop the single core with 1-0-0 repeat  
 void loop() {  
  delayMicroseconds(cycleDelay); // cycle delay time  
    
  // Set Core to "1" state  
  digitalWrite(pin12, HIGH);  
  digitalWrite(pin11, HIGH);  
  digitalWrite(pin9, HIGH);  
  //onDelay ~8 microseconds  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\t");  
  digitalWrite(pin12, LOW);  
  digitalWrite(pin11, LOW);  
  digitalWrite(pin9, LOW);  
  //offDelay ~8 microseconds  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\t");  
    
  // Set Core to "0" state  
  digitalWrite(pin12, HIGH);  
  digitalWrite(pin10, HIGH);  
  digitalWrite(pin8, HIGH);  
  //onDelay ~8 microseconds  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\t");  
  digitalWrite(pin12, LOW);  
  digitalWrite(pin10, LOW);  
  digitalWrite(pin8, LOW);  
  //offDelay ~8 microseconds  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\t");   
    
    
  //Set Core to "0" state  
  digitalWrite(pin12, HIGH);  
  digitalWrite(pin10, HIGH);  
  digitalWrite(pin8, HIGH);  
  //onDelay ~8 microseconds  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\t");  
  digitalWrite(pin12, LOW);  
  digitalWrite(pin10, LOW);  
  digitalWrite(pin8, LOW);  
  //offDelay ~8 microseconds  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\tnop\n\tnop\n\tnop\n\tnop\n\tnop\n\t");  
  __asm__("nop\n\t");  
 }  
   

Arduino Morse Code Decoder

I came across this Arduino Morse Code Decoder Sketch by Budd WB7FHC HERE and it look interesting and very well documented so I thought I would try it out and run some tests on it because I may have an application for such a decoder.

Using a straight key with it was a little tough but I was able to get it to copy me fine as long as I was sending perfectly at about 10 WPM. I tried increasing the speed but it seems to get easily confused requiring a reset.
I then decided to connect a keyer to it so it was receiving perfect machine generated Morse. I used my WINKEYER USB. I started at 10 WPM and was able to increase the speed in 2-3 WPM increments and it was able to copy 100% all the way to 99 WPM!

I still need to do more testing but the way the code is built, it seems to needs to start at a slow speed before handling higher speed code. I did find that from a reset it will copy perfectly at 10 WPM every time with virtually no training. It seems the training part of the code is more useful when dealing with a straight key and the variation that a human may cause.

I came across some minor issues in the code while I was running it regarding decoding punctuation. The fix required a change to the "mySet" array and also the punctuation code. If you look at the printPunctuation code on Budds original sketch and compare to my code below I just did a direct print instead of assigning it to "pMark". I also made it so when it decodes a "@" sign it sends a newline to the terminal.

There are some other changes I would like to make that would enable this code to work in an application I am pondering... a CW transponder. The idea would be to send it my call-sign and a command, it would decode it and if correct would respond with an appropriate CW response back (transpond). For example, if I send it... WA6PZB WA6PZB CMD WX CMD WX it would respond back with WA6PZB WA6PZB RESP 72F RESP 72F. Here I am requesting the temperature or weather (WX) and it is responding with 72 degrees F. I am expecting to send everything twice in and attempt to get the signal through under varying conditions since Morse has no error correction.

 /* Barnacle Budd's Morse Code Decoder v. 0.1  
   (c) 2011, Budd Churchward - WB7FHC  
   Minor modification by WA6PZB 8/30/2014  
   Hook a button or telegraph key up to your Arduino  
   and this program will copy your Morse Code and display  
   the characters in your Monitor window.  
   The program will automatically adjust to the speed of code that  
   you are sending. The first few characters may come out wrong.  
   The software tracks the speed of the sender's dahs to make  
   its adjustments. The more dahs you send at the beginning  
   the sooner it locks into solid copy.  
   After a reset, the following text is very difficult to lock in on:  
   'SHE IS HIS SISTER' because there are only two dahs in the whole  
   phrase and they come near the end. However, if you reset and then  
   send 'CALL ME WOODY' it will match your speed quite quickly.  
 */  
 int myKey=14;  // We are borrowing Analog Pin 0 and using it as digital  
 int speaker=11; // Speaker will be hooked between pin 11 and ground  
 int val=0;          // A value for key up and down  
 int myTone=640;       // Frequency of our tone  
 boolean ditOrDah=true;    // We have a full dit or a full dah  
 int dit=100;         // If we loop less than this with keydown it's a dit else a dah  
 int averageDah=150;     // Start with this value we will adjusted it each time he sends a dah  
 boolean characterDone=true; // A full character has been sent  
 int myBounce=2;       // Handles normal keybounce but we needed to do more later  
 int downTime=0;       // We are going to count the cycles we loop while key is down  
 long FullWait=10000;   // This value will be set by the sender's speed - the gap between letters  
 long WaitWait=FullWait; // WaitWait is for the gap between dits and dahs  
 long newWord=0;     // For the gap between words  
 int nearLineEnd=40;   // How far do you want to type across your monitor window?  
 int letterCount=0;    // To keep track of how many characters have been printed on the line  
 int myNum=0; // We will turn the dits and dahs into a data stream and parse  
        // a value that we will store here  
 // The place a letter appears here matches the value we parse out of the code  
 char mySet[] ="##TEMNAIOGKDWRUS##QZYCXBJP#L#FVH09#8###7#:###/#61#######2###3#45";  
 void setup() {  
  pinMode(myKey, INPUT);  
  pinMode(speaker,OUTPUT);  
  // initialize the serial communication:  
  Serial.begin(9600);  
 }  
  void loop() {  
   val=digitalRead(myKey); // Is it up or is it down?  
   if (val) keyIsDown();  // Any value here means it is down.  
   if (!val) keyIsUp();   // Should be 0 when it is up.  
  }  
  void keyIsDown() {  
   tone(speaker,myTone); // Turn on the sound  
   WaitWait=FullWait;   // Reset our Key Up countdown  
   downTime++;  //Count how long the key is down  
  if (myNum==0) {    // myNum will equal zero at the beginning of a character  
    myNum=1;     // This is our start bit - it only does this once per letter  
   }  
  characterDone=false; // we aren't finished with the character yet, there could be more  
  ditOrDah=false;    // we don't know what it is yet - key is still down  
  delay(myBounce);   // short delay to keep the real world in synch with Arduino  
  }  
  void keyIsUp() {  
   noTone(speaker);   // Turn off the sound  
  if (newWord>0) newWord--;   // Counting down to spot gap between words  
  if (newWord==1) printSpace(); // Found the gap, print a space but only once next time it will be 0  
  if (!ditOrDah) {       // We don't know if it was a dit or a dah yet, so ...  
    shiftBits();       // let's go find out! And do our Magic with the bits  
   }  
  if (!characterDone) {  
    WaitWait--;        // We are counting down   
    if (WaitWait==0) {    // Bingo, keyUp just timed out! A full letter has been sent  
     WaitWait=FullWait;   // Reset our keyUp counter  
     printCharacter();    // Go figure out what character it was and print it  
     characterDone=true;   // We got him, we're done here  
     myNum=0;        // This sets us up for getting the next start bit  
    }  
    downTime=0;        // Reset our keyDown counter  
   }  
 }  
 void printSpace() {  
  letterCount++;         // we're counting the number of characters on the line   
  if (letterCount>nearLineEnd) { // when we get past our threshold we do this:  
   Serial.println();       // jump down to a new line  
   letterCount=0;        // reset our character counter  
   return;            // Go back to loop(), we're done here.  
  }   
  Serial.print(' ');       // print a space on the monitor window  
 }  
 void printCharacter() {        
  FullWait=averageDah*100;    // the keyUp counter gets reset based on sender's speed  
  newWord=FullWait*5;       // word gap counter is also adjusted by sender's speed  
  letterCount++;         // we're counting the number of characters on the line  
  if (myNum>63) {   
   printPunctuation();      // The value we parsed is bigger than our character array  
                  // It is probably a punctuation mark so go figure it out.  
   return;            // Go back to the main loop(), we're done here.  
  }  
  Serial.print(mySet[myNum]);   // Print the letter that is in this spot in our character set  
 }  
 void printPunctuation() {  
  byte pMark='#'; // Just in case nothing matches  
  if (myNum==71) Serial.print(":");  
  if (myNum==76) Serial.print(",");  
  if (myNum==84) Serial.print("!");  
  if (myNum==94) Serial.print("-");  
  if (myNum==101) Serial.println(); // the @ sign used for newline  
  if (myNum==106) Serial.print(".");  
  if (myNum==115) Serial.print("?");  
 }  
 void shiftBits() {  
  ditOrDah=true;    // we will know which one in two lines  
  if (downTime<dit/3) return; // ignore my keybounce  
  if (downTime<dit) {  
   // We got a dit  
   myNum = myNum << 1; // shift bits left  
   myNum++;       // add one because it is a dit  
  }  
  else {  
   // We got a dah  
   myNum = myNum << 1; // shift bits left  
   // The next three lines handle the automatic speed adjustment:  
   averageDah=(downTime+averageDah)/2; // running average of dahs  
   dit=averageDah/3;          // normal dit would be this  
   dit=dit*2;              // double it to get the threshold between dits and dahs  
  }  
 }  

PFR-3A Build (Battery Pack)

The PFR-3A is complete now, I completed the battery pack as well the paddle. I also added a fuse to the battery pack as recommended in the build instructions. I put a quick disconnect on the battery line so the top an bottom can be separated.








The paddle is a little touchy but very nice to have since it make it an all-in-one package.

I plan to take it on a hike soon with some wire to build a simple half wave end-feed antenna. I would like to get some QSOs logged with it in the field.

Here is the completed package shot in the field (my backyard).

PFR-3A Build (In the box)

I worked on getting the PFR-3A PCB mounted in the enclosure and wired to the coax, binding posts and switch connections. It is almost complete. Next is the battery pack.

PFR-3A Build

I had a PFR-3A kit I started in 2010 that got placed on the back burner. I decided to dig back into it and finish it up. I just needed to finish the transmit section and the low pass filters along with the antenna tuner. The transmitter has tested out OK and I now have all the labels on the case. As soon as the clear coat is dry on the case I will mount the PCB and finish the plug in paddle assembly.

In addition to CW, I want to try to use Hellschreiber with this radio and the iphone app to decode.

It is really a neat radio with the internal battery pack and antenna tuner, it is a self contained CW station.

Solar Power in the Desert part II

I visited my friend again in Arizona for 5 days to continue work on his solar array last week (from 7/31 to 8/4). He had made some progress since my last visit HERE but it was tough going on his own. Working mostly at night due to the high (100+ degree F) daytime temperatures, we completed the welding of the full array frame and then mounted and connected all 40 panels to the system. Below is a picture of the completed 65 foot long array.

The array is aligned due south, however you may have noticed that near by tree. We have observed that the tree reduces the output of the first quarter of the array by over 10% in the morning (1-3 hours max from sun up). Since the array is over sized it is probably not a big deal. When the instrumentation has collected a full season of data it can be re-evaluated.

During our stay we had a powerful rain storm blow through with high winds which confirmed the design of the heavy steel frame. The storm did display some lightning but no nearby strikes were observed. Full lightning protection is not installed yet but we did get the first ground rod installed before we left. Lightning rods or air terminals are planned for a tall security light pole and some of the buildings and possibly the array as well.

To give some scale as to the size of the array, here is a picture of my friend and I with a truck in front of the array.

The configuration has changed a bit since last time since obtaining a single 12kw split phase inverter instead of the two 6kw units. This single inverter is a 48 volt only unit, so the 8 batteries are now configured as two series banks of four in parallel. The 48 volt configuration is preferred since the charge controllers can be better utilized up to their maximum 40 amps at 48 volts verses 24 volts in the previous configuration. This 12kw AIMS Power Inverter has not functioned as expected and fails intermittently on various load changes. A replacement has been on  order for months but has yet to arrive which brings into question the stability of both the unit and the company. Since there is a need for three phase power on the ranch, a split phase to three phase mechanical converter was obtained, however it is one of the loads that the 12kw inverter fails on currently. Recent research has now found that Outback Power has an inverter model VFX3648 that is capable of being setup to generate three phase power directly with three units combined. This would be a better solution and eliminate the mechanical phase converter. There is additional cost in this solution but taking in to consideration the issues (and wasted time) with the AIMS unit and the losses from a mechanical phase converter this may be the way to go in the future.

There is still a lot of work to do in terms of electrical on this ranch. There is the 25kw 3-phase diesel generator that is currently being used for water pumping due to the well pump being a 3-phase water pump (since the solar can't run it yet!) and now a second diesel generator has been revived for use now too. This second gen-set is a 10 kw 3-phase unit, which may save fuel while just running the water pump. In any event these electrical sources will need to be wired into a set of panels so the power can be routed where needed in the event of a failure of any of these sources. Also a small wind turbine is also planned for solar backup.

JT65A Sandbox Environment

After working with JT65A on HF now for a couple of weeks I wanted to better understand it, and explore some of it limits, particularly how weak a signal can be and the effects of poor time synchronization. I set out to connect up a simple sandbox environment. I wanted the environment to be independent of the Internet so that meant I needed a local time source using NTP. The sandbox environment has two (2) PC stations running WinXP and JT65 HF v1.0.9.3 HERE and a Meinberg NTP client HERE. Theses are connected to each other via a passive audio mixer. In addition a third PC is running Linux with NTP and Audacity. All the PC are on a common LAN. The following drawing shows the basic layout:

The first step is to configure the NTP server on the Linux PC to act as a time source. The main point here is to provide a common time source for the two WinXP PCs to sync their clocks with to within +/- 1 second per the JT65A requirements. They don't have to be sync'd to the "real" time just a time. The NTP package used is the standard Linux NTP. The /etc/ntp.conf file just needs a simple addition. The following two lines need to be added the the /etc/ntp.conf file:

server 127.127.1.0 fudge 127.127.1.0 stratum 10

Once this change is made the NTP server will need to be restarted or you can just restart the Linux PC. Now with the time server on the network the two WinXP PCs will need to know about it so the ntp.conf file on each PC will need the time server name or IP address added to the the current list of time servers. The Meinberg NTP application has a shortcut to edit the file just by going to Programs>Meinberg>Network Time Protocol>Edit NTP Configuration. Just add the following line:

server mytimeserver iburst

After this edit you will need to restart NTP which is available via Programs>Meinberg>Network Time Protocol>Restart NTP. Now you can use the Meinberg NTP status command via Programs>Meinberg>Network Time Protocol>Quick NTP status. You should see your NTP server listed with a delay, offset and jitter values well under 1000. These are in milliseconds, so you should see values under 200-600 milliseconds for the offset. If all values are zero, something is wrong and your NTP client is not seeing your NTP server or your NTP server is not running or configured correctly.

Now you are almost ready to use the sandbox environment. Next you will need to simulate the band noise. I am using Audacity on the Linux PC as noise source. I just start up Audacity then I generate 30 seconds of noise which is a built-in function of the tool. Then I loop that noise in the player which will keep playing over and over until you stop it. Look at the Audacity web site for details and tutorials HERE. Next we get JT65 HF running on both WinXP PCs and adjust the noise level so that both are adjusted to 0 db in the JT65 HF client using a combination of its level controls and the passive mixer. The passive mixer has is just a resistor network. Each mixer channel is a 50k ohm potentiometer followed by a 50k ohm resistor. The input comes from the audio out of one PC and the output of the mixer goes to the mic input of the other PC. Below is one channel of the mixer. 

All the the outputs of the passive mixer are tied together to go to all the mic inputs. So for this environment three channels are needed (one for each PC plus the noise source), see the basic layout drawing above.

With this setup, I have been able to simulate signal levels from -3 db to -22 db. I may use this environment to demonstrate JT65A and other digital modes like PSK31, RTTY, FELD HELL and others.

Portable Antenna Tripod

Since I will be needing two general purpose WiFi antenna portable tripods for HSMM range tests I set out to build one based on this DESIGN. I had most of the wood and just needed the hinges and some bolts. It turned out better than I expected and is amazingly strong. I have not measured the weight of it yet but I would say it is at least 10 pounds (4.5 kg). Here is a picture of the first one that I finished last night just before dark with one of the Cisco antennas attached.

It is not as tall as I wanted but it needs to fit in the back seat of a small car. The original Cisco dish mount allows for some articulation. I will be able to get +/- 45 degrees elevation and about +/- 15 degrees in azimuth. If I need more range than that I will have to pick up the tripod and move it. Hopefully I will get some more time this coming week the complete the second tripod. My first range test will be a 1-2 mile path. 

JT65 HF mode

I decided to try JT65 HF. W6CQZ has packaged up Joe Taylor's K1JT JT65A mode in a easy to use program.

I briefly read the ARRL guide HERE, and I was able to make a contact (WE7P - Bruce in Tacoma Washington) in under 5 minutes on 15 meters.

This is not a rag chew mode but uses a very simple set of exchanges, however it makes the best of low power and simple antennas (which I like). I have only worked a few state side contacts so far but I am hearing DX stations too. I also worked another station (N3GTY -  William in Spring Lake North Carolina) on 20 meters.

The other thing that is neat about the JT65 HF client is that everyone running it can be a reverse beacon monitor. I noticed that one of my CQ's was heard in Japan by a stations client setup to report the spots into PSK Reporter.

Crystal Set in storage for the Summer

This last winter I built a simple crystal set radio receiver using oatmeal containers for the inductor forms and a cats whisker assembly along with a couple of variable capacitors. It has been setting on my bench taking up too much room so I thought I would document the build and then store it away. I should  create a chassis or base for it the next time I assemble it. This is the basic schematic.

The antenna was a simple slinky stretched in the attic of the garage, it of course would work better with a larger antenna but my outside dipole is in use for other radio activities. The antenna connection goes to a dual ganged 365 pf variable capacitor (C1) then through a 35 turn inductor wound on the first oatmeal container and then to a cold water pipe ground. The ground is very important for crystal sets. Next I have about 60 turns of wire on the second inductor with taps every 5 to 6 turns. The second inductor is another oat meal container. The two inductors are sitting on top of each other as you can see in this photo. No electrical connection between the two inductors.

Ideally if I set this up again, I will position the inductors horizontally on a wooden rod or something to be able to adjust  the air coupling between the two. The first inductor circuit is the antenna tuner and the second inductor forms the resonate tuning to the desired frequency with capacitor C2. The antenna tuner section could be with a series capacitance like I am using or it could be in parallel depending on the size of the antenna. Some crystal sets let you change all the connection which makes them very versatile. I was using clip leads so I could easily adjust the configuration. My diode detector is a modified MidnightScience unit. It came with a galena crystal, however I found that iron pyrite worked the best for me. I used a 1/2 inch copper pipe cap with adjustment screws to hold the pyrite crystal in place. The chunk I had was much larger than the galena sized holder so I needed to build my own holder.  The pyrite detector is typically twice as loud as the galena with the antenna I use. I have also tested germanium as well and in this set, the pyrite is the best.

With my simple indoor antenna and a good ground, I was able to receive several stations. The strongest were KFI (640 khz) and KNX (1070 khz). Fortunately  these stations had some separation. Two strong stations near each other on a crystal set can be a problem. KNX is actually near a weaker Spanish station that required delicate tuning but with the separate antenna tuning and frequency tuning it did pretty well. The other key to crystal sets are the headphones. I have two pairs of antique high impedance (2000 ohm) magnetic headphones. The ones I used on this set don't look that great but work well. I have also used the small piezo ear pieces but they fail if left connected to the radio for any length of time and in general are not very rugged. I have built many crystal sets over the years but they still bring great enjoyment and fun.