NAQP RTTY in the books

Didn’t have much time to operate today but still managed to get a few
QSOs in the log. For fun I played with the statistics in N1MM+.

naqprtty-stats

NA QSO RTTY – 2015-02-28 1800Z to 2015-03-01 0600Z – 215 QSOs
K5TRI – Off Times >= 30 Minutes

2015-02-28 1800Z – 2015-02-28 1810Z     00:11  (11 mins)   (Start late)
2015-02-28 1945Z – 2015-02-28 2344Z     04:00  (240 mins)
2015-02-28 2346Z – 2015-03-01 0202Z     02:17  (137 mins)
2015-03-01 0353Z – 2015-03-01 0430Z     00:38  (38 mins)

Total Time Off 07:06  (426 mins)
Total Time On 04:19  (259 mins)

NA QSO RTTY – 2015-02-28 1800Z to 2015-03-01 0600Z – 215 QSOs
K5TRI Max Rates:

2015-03-01 0223Z – 3.0 per minute  (1 minute(s)), 180 per hour by K5TRI
2015-02-28 1926Z – 1.7 per minute  (10 minute(s)), 102 per hour by K5TRI
2015-02-28 1938Z – 1.1 per minute  (60 minute(s)), 68 per hour by K5TRI

NA QSO RTTY – 2015-02-28 1800Z to 2015-03-01 0600Z – 215 QSOs
K5TRI Runs >10 QSOs:

2015-02-28 1840 – 1944Z,   21092 kHz, 73 Qs, 68.5/hr K5TRI
2015-03-01 0216 – 0300Z,   14094 kHz, 45 Qs, 60.8/hr K5TRI
2015-03-01 0312 – 0352Z,    7075 kHz, 41 Qs, 61.4/hr K5TRI
2015-03-01 0434Z – 0519,    7067 kHz, 33 Qs, 43.7/hr

New FSK/CW interface

Took some time tonight to re-build my FSK interface for the TS-2000 and
add CW keying for the upcoming ARRL DX CW contest. Looks much nicer
now.

IMAG00016 (3)

IMAG00021 (3)

Also had to made a pig tail to get all the signals out separately to be
able to use it with multiple radios.

IMAG00018 (3)

500mW QRP fun

IMAG00014 (3)

Hooked up the Rockmite 40 and tried to make some contacts. But 500mW didn’t
make it very far. Frequency was busy so I just spent some time listening on the
little guy.

K5TRI Rotorduino Source Code

I finally found some time to post the source for my rotor controller I posted about a long time ago. Maybe some day I will also find time to make the schematic. I never drew schematics in a proper tool other than on a piece of paper. It should however be somewhat self explanatory. As the saying goes:”The documentation is in the source” :).

  1. /*
  2. Simple 3-wire rotor controller for tracking satellites.
  3. This code uses an existing AZ only simple rotator to track satellites using the EASYCOM I
  4. protocol.
  5.  
  6. This code was written by Michael Schulz (K5TRI) and is licensed under the GPLv2
  7. Comments and improvements welcome at mschulz@creative-chaos.com
  8.  
  9.  
  10.  
  11. GPredict users:
  12.  
  13. In the antenna controller you need to set the Tolerance to 0.01. If left at
  14. 5.0 degrees, the value sent to the controller on switchover from 0 deg to 360 will go back
  15. and forth causing the rotor to do two full turns!
  16.  
  17.  
  18. */
  19.  
  20.  
  21. #include <LiquidCrystal.h>
  22. #include <EEPROM.h>
  23. #include "EEPROMAnything.h"
  24. #include <Wire.h>
  25. //#include <Adafruit_MCP23017.h>
  26. //#include <Adafruit_RGBLCDShield.h>
  27.  
  28. // The shield uses the I2C SCL and SDA pins. On classic Arduinos
  29. // this is Analog 4 and 5 so you can't use those for analogRead() anymore
  30. // However, you can connect other I2C sensors to the I2C bus and share
  31. // the I2C bus.
  32.  
  33. //Adafruit_RGBLCDShield lcd = Adafruit_RGBLCDShield();
  34.  
  35.  
  36.  
  37. // These #defines make it easy to set the backlight color for use with Adafruit I2c LCD shield
  38.  
  39. /*#define RED 0x1
  40. #define YELLOW 0x3
  41. #define GREEN 0x2
  42. #define TEAL 0x6
  43. #define BLUE 0x4
  44. #define VIOLET 0x5
  45. #define WHITE 0x7
  46. */
  47.  
  48. struct azimuth_t
  49. {
  50.     int az_cur;
  51. } azim;
  52.  
  53.  
  54.  
  55. // initialize the library with the numbers of the interface pins
  56. LiquidCrystal lcd(13, 12, 11,10, 6, 5);
  57.  
  58.     unsigned char relayEXEpin = 9;
  59.     unsigned char relayROTpin = 8;
  60.     unsigned char rotButCCW = 3;
  61.     unsigned char rotButCW = 4;
  62.     char inputData[19];
  63.     int s;
  64.     int lastexe;
  65.     int idle;
  66.     int startidle;
  67.     int az_temp;
  68.     int b;
  69.     int predictInput[12];
  70.     byte startbyte;
  71.     int ButtonState = 0;
  72.     unsigned long time_on;
  73.     unsigned long time_off;
  74.     unsigned long time_diff;
  75.  
  76.     int ButtonCW();
  77.     int ButtonCCW();
  78.    
  79.    
  80. void setup()
  81.  
  82. {
  83.  
  84.   // retrieve stored position from memory
  85.   // int az_cur;
  86.  
  87.   EEPROM_readAnything(0, azim.az_cur);
  88.  
  89.   // Make sure rotor is turned off
  90.   digitalWrite(relayEXEpin,LOW);
  91.  
  92.  // set up the LCD's number of columns and rows:
  93.  
  94.   lcd.begin(16, 2);
  95.   lcd.setCursor(0,0);
  96.   lcd.clear();
  97.  
  98.   //display current postion of rotor
  99.  
  100.  
  101.   //Idle message while waiting for commands
  102.   lcd.clear();
  103.   lcd.print("K5TRI RotorDuino");
  104.   lcd.setCursor(0,1);
  105.   lcd.print("Current pos: ");
  106.   lcd.print(azim.az_cur);
  107.  
  108. // initialize the serial communications:
  109.  
  110.   Serial.begin(9600);
  111.  
  112. // define relay pins for rotor control
  113.  
  114.     pinMode(ledCCWpin,OUTPUT);
  115.     pinMode(ledCWpin,OUTPUT);
  116.     pinMode(relayEXEpin,OUTPUT);
  117.     pinMode(relayROTpin,OUTPUT);
  118.    
  119.     pinMode(rotButCCW,INPUT);
  120.     pinMode(rotButCW,INPUT);
  121.    
  122.  
  123. }
  124.  
  125. void loop()
  126.  
  127.     {
  128.  
  129.  
  130.         startidle = (millis() /1000);
  131.  
  132.        
  133.         EEPROM_readAnything(0, azim.az_cur); // Get current position stored in EEPROM
  134.         azim.az_cur = constrain(azim.az_cur, 0, 360); //Limit rotor positioning between 0 and 360 degrees
  135.  
  136.         //manual CCW button pressed
  137.         if (digitalRead(rotButCCW) == HIGH)
  138.         {
  139.             lcd.clear();
  140.             time_on = millis();
  141.             ButtonCCW();
  142.             //EEPROM_readAnything(0, azim.az_cur);
  143.             lcd.clear();
  144.             lcd.setCursor(0,0);
  145.             lcd.print("Current position: ");
  146.             lcd.setCursor(0,1);
  147.             lcd.print("Azimuth: ");
  148.             lcd.print(azim.az_cur);
  149.             lcd.print(" deg");
  150.         }
  151.        
  152.  
  153.         //manual CW button pressed
  154.  
  155.         if (digitalRead(rotButCW) == HIGH)
  156.         {
  157.             lcd.clear();
  158.             time_on = millis();
  159.             ButtonCW();
  160.             //EEPROM_readAnything(0, azim.az_cur);
  161.             lcd.clear();
  162.             lcd.setCursor(0,0);
  163.             lcd.print("Current position: ");
  164.             lcd.setCursor(0,1);
  165.             lcd.print("Azimuth: ");
  166.             lcd.print(azim.az_cur);
  167.             lcd.print(" deg");
  168.         }
  169.  
  170.         //turn off rotor
  171.         digitalWrite(relayEXEpin, LOW);
  172.  
  173.  
  174.  
  175.  
  176.  // wait for serial input full serial line data (min 12 bytes in buffer)
  177.  
  178. if (Serial.available() > 12) {
  179.  
  180.    
  181.     //read the first byte
  182.     startbyte = Serial.read();
  183.  
  184.     // check for the start of the serial string (65) ASCII (A)
  185.     if (startbyte == 65)
  186.    
  187.     {    
  188.    
  189.         for (s=0; s<12;s++)
  190.         {
  191.             predictInput[s] = Serial.read();
  192.            
  193.         }
  194.  
  195.                
  196.     char az[5] = { predictInput[1], predictInput[2], predictInput[3] };
  197.    
  198.     // write input value to serial for debugging
  199.     Serial.print("Input: ");
  200.     Serial.println(az);
  201.    
  202.     int az_new = atoi(az);  //Convert azimuth char string to integer
  203.        
  204.     az_new = constrain(az_new, 0, 359); //limit azimuth between 0 and 359 degrees
  205.  
  206.     // arite AZ value to serial for debugging purposes
  207.    
  208.         Serial.print("AZ NEW: ");
  209.         Serial.println(az_new);
  210.    
  211. // Rotor function
  212.  
  213.  
  214. // Calculate direction
  215.     long az_diff = az_new - azim.az_cur;
  216.  
  217.     //If az_diff is < 0 then turn CCW
  218.     if (az_diff < 0) {
  219.         digitalWrite(ledCCWpin,HIGH);
  220.         digitalWrite(relayROTpin,LOW);
  221.     }              
  222.  
  223.     else digitalWrite(ledCCWpin,LOW);
  224.  
  225.     //If az_diff > 0 then turn CW
  226.     if (az_diff > 0) {
  227.         digitalWrite(ledCWpin,HIGH);
  228.         digitalWrite(relayROTpin,HIGH);
  229.     }      
  230.  
  231.     else digitalWrite(ledCWpin,LOW);
  232.  
  233.  
  234. // Calculate timing
  235.  
  236.         if (az_diff < 0) az_diff = -az_diff;
  237.         unsigned long exec_time = az_diff * 180UL;
  238.  
  239.         //If az_diff > 5 degrees then turn. This can be set to whatever azimuth difference desired
  240.         if (az_diff > 5) {  
  241.  
  242.         // Turn rotor
  243.        
  244.        
  245.             lcd.clear();
  246.             lcd.setCursor(0,0);
  247.             lcd.print("Turning ...");
  248.  
  249.             digitalWrite(relayEXEpin, HIGH);
  250.             delay(exec_time);
  251.             digitalWrite(relayEXEpin,LOW);
  252.            
  253.             lcd.clear();
  254.             lcd.print("Current position:");
  255.             lcd.setCursor(0,1);
  256.             lcd.print(az_new);
  257.             lcd.print(" deg");
  258.        
  259.             lastexe = (millis() / 1000);
  260.        
  261.         //Set az_cur
  262.         azim.az_cur = az_new;
  263.         //Write az_cur to EEPROM
  264.         EEPROM_writeAnything(0,azim);
  265.        
  266.     }
  267.        
  268.     }
  269.   }
  270.  
  271.     idle = startidle - lastexe;
  272.  
  273.     if (idle > 59)
  274.  
  275.         {
  276.                 lcd.setCursor(0,0);
  277.                 lcd.print("K5TRI RotorDuino");
  278.                 lcd.setCursor(0,1);
  279.                 lcd.print("Current pos: ");
  280.                 lcd.print(azim.az_cur);
  281.         }
  282. }
  283.  
  284.  
  285.  
  286.  
  287. int ButtonCW()
  288. {
  289.  
  290.    
  291.        
  292.         while (digitalRead(rotButCW) == HIGH) {
  293.        
  294.         lcd.setCursor(0,0);
  295.         lcd.print("Manual CW ");
  296.         lcd.setCursor(0,1);
  297.         EEPROM_readAnything(0,azim);
  298.                
  299.             Serial.print("on: ");
  300.             Serial.println(time_on);
  301.             digitalWrite(ledCWpin,HIGH);
  302.             digitalWrite(relayROTpin,HIGH);
  303.             digitalWrite(relayEXEpin, HIGH);
  304.             time_off = millis();
  305.             Serial.print("off: ");
  306.             Serial.println(time_off);
  307.        
  308.                 time_diff=time_off-time_on;
  309.                 Serial.print("diff: ");
  310.                 Serial.println(time_diff);
  311.                 b = (int) (time_diff / 180);
  312.                 az_temp = azim.az_cur + b;
  313.                 Serial.print("az_new: ");
  314.                 Serial.println(az_temp);
  315.                 lcd.print("Current pos: ");
  316.                 lcd.print(az_temp);
  317.                 lcd.print("   ");
  318.  
  319.                 lastexe = (millis() / 1000);
  320.                        
  321.     }
  322.    
  323.             //Prevent current position to be greater than 360 when using manual
  324.             //button to turn CW
  325.            
  326.         if (az_temp > 360) {(az_temp = 360);}
  327.                         azim.az_cur = az_temp;
  328.                         EEPROM_writeAnything(0,azim);
  329.                        
  330.  
  331.                 }
  332.                
  333.  
  334.  
  335.  
  336.  
  337. int ButtonCCW()
  338.  
  339. {
  340.          
  341.            
  342.             while (digitalRead(rotButCCW) == HIGH) {
  343.        
  344.          lcd.setCursor(0,0);
  345.          lcd.print("Manual CCW ");
  346.          lcd.setCursor(0,1);
  347.          EEPROM_readAnything(0,azim);
  348.  
  349.                 Serial.print("on: ");
  350.                 Serial.println(time_on);
  351.                 digitalWrite(ledCCWpin,HIGH);
  352.                 digitalWrite(relayROTpin,LOW);
  353.                 digitalWrite(relayEXEpin, HIGH);
  354.                 time_off = millis();
  355.                 Serial.print("off: ");
  356.                 Serial.println(time_off);
  357.                    
  358.                     time_diff = time_off - time_on;
  359.                     Serial.print("diff: ");
  360.                     Serial.println(time_diff);
  361.                     b = (int) (time_diff / 180);
  362.                     az_temp = azim.az_cur - b;
  363.                     Serial.print("az_new: ");
  364.                     Serial.println(az_temp);
  365.                     if (az_temp < 0) {(az_temp = 0);}
  366.                     lcd.print("Current pos: ");
  367.                     lcd.print(az_temp);
  368.                     lcd.print("   ");
  369.  
  370.                     lastexe = (millis() / 1000);
  371.             }
  372.    
  373.  
  374.            // Prevent current position reading from being negative when using manual
  375.            // buttons to turn CCW
  376.            
  377.             if (az_temp < 0) {(az_temp = 0);}
  378.                azim.az_cur = az_temp;
  379.                EEPROM_writeAnything(0,azim);
  380.                        
  381.                 }

New QSL card

The new QSL cards arrived and a stack already sent out. Looking good.

k5tri-card

The photo was shot in 2013 on a hike around Mt. St. Helens on a sheet of
4×5 Ilford FP4.

Another blue TS-2000

Got another TS-2000 (again). It is a good radio after all. Tried next to a TS-590S
I could not make out a dramatic difference in weak CW signals. But that amber
display light … that’s just wrong :)
IMAG00027

I wrote about the process here before. Next up the 1st IF tap to hook up an RTL-SDR.