Make It Tea - public:radio:topics

4m FM

anonymous@undisclosed.example.com (Anonymous) — Thu, 04 Jun 2026 18:22:49 +0000

4m FM

Low Band PMR and 4m Ham band

Background

The PMR radio system for the Shetland Islands Council (SIC) Roads dept. is being re-engineered (summer 2023) with new base station radios and a new IP based microwave link network.

I thought I would set myself up with the ability to monitor, and test coverage, both mobile and at home. I found my old FM1100 and also was given a selection of other ones by SIC, as well as the PDP to program them.

My plan is to configure the radios for both 4m ham band and SIC roads network.

Frequencies

SIC Roads PMR

Site	Base TX	Base RX	CTCSS
Bressay	85.425	71.925	103.5
Weisdale	85.350	71.850	103.5
Collafirth Hill	85.225	71.725	103.5

4m Amateur Band

12.5kHz spacing
- 70.3000
- 70.3125
- 70.3250
- 70.3375
- 70.3500
- 70.3625
- 70.3750
- 70.3875
- 70.4000
- 70.4125
- 70.4250
- 70.4375
- 70.4500 = FM Calling Channel
- 70.4625
- 70.4750
- 70.4875

Business Radio Simple Light

5 channels
- 77.6875
- 86.3375
- 86.3500
- 86.3625
- 86.3750

— John Pumford-Green 20/05/23 12:25

Further Information

fm1100, 4m, radio

10m/12m

anonymous@undisclosed.example.com (Anonymous) — Thu, 04 Jun 2026 18:23:23 +0000

←Radio Topics

10m/12m

A diversion into 10m and 12m

Equipment

~~Shack : CRT SS9900~~
Shack : Icom IC-706
Mobile : Anytone Smart CB for 10M

Antenna

Sleeve “T2LT” dipole
- Sloping at approx. 45°
- Choke 5T 110mm diameter air wound

Choke design recommendations :

Update 22/5/23 : Moved to fully vertical with choke/feedpoint 2m agl and tip @ 7m agl
- using 7m “Sota pole”
Update 4/6/12 : moved back to sloping configureaton on original 5m long pole, and choke/radiator/feedpoint changed to suit 12m : choke now 6T on 110m former at 3m from “feedpoint”
- radiator section lengthened to 3m.

(Photo to follow)

Propagation Data

10m WSPR Spots vs SFI & K indices

Date	Time First Spot	Time Last Spot	Power	Spots In	Min/Max/Ave km	Spots Out	Min/Max/Ave km	SFI	SSN	K	48H Flare
10/05/23	(1442)	2010	5W	3	2939 / 2939 / 2939	26	2939 / 10373 / 4043	180	151	5	M6.5
10/05/23	2332	0122	5W	7	1008 / 1605 / 1297	9	1175 / 1743 / 1348	180	151	5	M6.5

Last Update : 04/06/26 19:23 BST

Further Information

https://www.radio-workshop.co.uk/cb-radio-citizens-band-27mhz-11-metres/

radio, 10m, 11m, cb

60m

anonymous@undisclosed.example.com (Anonymous) — Thu, 04 Jun 2026 06:58:36 +0000

←Radio Topics

60m

A return to 60m in earnest

I've been active on 60m since it was first available (with a NOV) - and mostly in Digimodes on FK / 5366.5kHz, along with a bit of CW and very little SSB. For many years 60m digimodes was the only activity I did on the radio. In recent years I've been largely QRT, or having the odd spell on CW, but I still have an interest in 60m as a place for experimentation and for inter-UK communications. 2024 will be my year of 60m, with more SSB operating.

Band Utilization

Captured well by G3NRW's chart uk_60m_5_mhz_band_utilization_chart_band_plan_by_g3nrw.pdf
Since this chart was first produced many more European countries have access to 60m - mostly using the WARC allocation 5351.5 → 5366.5
The UK was first to have access to 60m but we are now out of touch with how the band is developing, locked in our unique set of bandlets.
Digimodes among UK stations still takes place on 5366.5kHz (USB Dial) which is an RF centre frequency of 5368.0. This is therefore out of the WARC allocation.
- Many Eu hams choose to ignore this - the WARC allocation goes to 5366.5kHz and if they set their radios to 5366.5kHz they operate there ignoring the fact that their actual signal is out of band.
- I tend to just work them and leave them to juggle the legalities.
I still see the band as interesting mainly for it's use as quiet, mostly channelized band for inter-UK experiments, rather than a band for “working DX”.
The WARC band has evolved its own internal band-plan.
- IARU Bandplan including 5MHz WARC hf_r1_bandplan.pdf

5351.5 → 5354.0	5354.0 → 5358.0	5358.0 → 5362.0	5362.0 → 5366.0	5366.0 → 5366.5
CW NOT UK	All Modes UK OK FT8 @ dial 5357 UK Beware band edge	All Modes NOT UK	All Modes UK OK SSB 5363 Common	Weak Signal UK OK WSPR @dial 5364.7

USA

Channel	Dial	Centre	Comments
1	5330.5	5332.0
2	5346.5	5348.0
3	5357.0	5358.5	In WARC : FT8
4	5371.5	5373.0	Shared UK
5	5403.5	5405.0	Shared UK

100W PEP ERP
Data & CW must be on centre frequency of channel (FT8 on 5357.0 + 1.5kHz ONLY??)

Canada

Same channels as USA
Also WARC Band 5351.5 → 5366.5 at 100W ERP

UK : Occupancy versus Bandlet/channel

I plan to investigate which bandlets are used for amateur QSOs and where/when any non-ham, commercial, military and UNID activity blocks access to our allocated spectrum.
- Which bandlets are clobbered regularly?
- Which bandlets have clear SSB channels most of the time?
- Where are the regular amateur nets, QSOs, CQ calls?

UK Bandlet List

No.	Start → Stop	Width	Comments (*Centre of Activity*)	SSB Dial range	Utilization 2024	CQ?	Non Ham Occupancy
1	5258.5 → 5264.0	5.5	FA 5258.5 *UK CW @ 5260.0*		CW @ 5260.0	CQ
2	5276.0 → 5284.0	8.0	FB 5278.5	5276.0 → 5281.0	5279.0		Fishfone
3	5288.5 → 5292.0	3.5	FC 5288.5 BEACONS & WSPR ONLY		Beacons W @ 5287.2
4	5298.0 → 5307.0	9.0		5298.0 → 5304.0			5298.0→5303.0 data@night 5304.0 clear
5	5313.0 → 5323.0	10.0	*UK AM @ 5317.0*	5313.0 → 5320.0	5320.0
6	5333.0 → 5338.0	5.0		5333.0 → 5335.0	5335.0		5333.0→5335.0 data@night
7	5354.0 → 5358.0	4.0	WARC FT8 @ 5357.0 USA Ch. 3 UK beware band edge	5354.0 → 5355.0
8	5362.0 → 5374.5	12.5	WARC→5366.5, WSPR 5363.0 SSB FK UK DIGI @ 5366.5 FL 5371.5 USA Ch. 4	5362.0 → 5371.5	5363.0 W @ 5364.7 D @ 5366.5 5371.5
9	5378.0 → 5382.0	4.0		5378.0 → 5379.0
10	5395.0 → 53401.5	6.5	FE UK SSB @ 5398.5	5395.0 → 5398.5	5395.0 5398.5	CQ	5395→5397 data@night FE Clear
11	5403.5 → 5406.5	3.0	FM 5403.5 USA Ch. 5 DX	5403.5	5403.5	CQ

SSB and “Dial Frequency” unless specified

W = WSPR
WL = Winlink
D = Digi (Olivia, MFSK, Contesia, PSK31 etc.)
DV = Digital Voice (FreeDV?)

Other 60m Users

User	Frequency	Location	Comments
UK Cadets	5245	Various	NRN - Replacement for 5345?
RAF Volmet	5450	England
Shannon Volmet	5505	Ireland
UK Rescue	5680	Various	Based at NMOC Fareham?
DRA5	5195	Germany	CW Beacon → DK0WCY
Aero	Various	Various	HF Utilities

Further Information

Exercise Blue Ham 2024

60m is shared in the UK with the Primary User - military - and we are allowed to have 2-way communication with Cadet Stations.
While they do appear occasionally on our shared bandlets they tend to be more active on their own specific cadet frequencies
Once or twice a year there is a better opportunity to work Cadet Stations - Exercise Blue Ham

The next Blue Ham is

June 17 - June 21 2024
All 5MHz UK SSB slots and data on 5366.5
See Alpha Charlie https://alphacharlie.org.uk/exercise-blue-ham/
See M0PLT https://www.m0plt.me.uk/blueham.php
Callsigns:
- Air Cadets : MRxyy
- Sea Cadets : MFxyy
- Army Cadets : (tbc)
- CCF : (tbc)

For other cadet radio info, as I find it, see Cadet Radio Info

60m band Wikipedia Page

https://en.wikipedia.org/wiki/60-meter_band#

— John Pumford-Green 31/03/24 18:50

Page Updated: 04/06/26 07:58 BST

60m, radio, ssb

CCIR493 Selcall

anonymous@undisclosed.example.com (Anonymous) — Thu, 04 Jun 2026 06:39:56 +0000

←Radio Topics

CCIR493 Selcall

HF Selcall Experiments

Background

I became interested in HF selcall when I was looking for a way of setting up impromptu QSOs with specific stations, for doing tests etc., without the need for listening by ear for calls. Various ideas were considered for controlling an audio mute, and alerting the operator, on HF, but nothing seemed appropriate (CTCSS, DTMF etc) until I stumbled on CCIR493 HF Selcall, specifically designed to cope with conditions on the HF bands.

The protocol was familiar, as it's very similar (but slightly simpler) than GMDSS DSC. This led to more reading and research. CCIR493 is widely used in Land Mobile HF SSB in Australia and in other countries which use HF SSB as a communications method. It seems largely unused in Europe. In Australia it is used on the networks set up to assist 4WD outback travellers, with Selcall used to initiate contact with the various base stations.

Selcall's beacon and 99 beacon functions can be used to check if a particular station is reachable before attempting a voice call.

This seemed ideal…. down the rabbit hole of HF Selcall…..

Basic details

CCIR493 HF Selcall is a predecessor to GMDSS DSC used in Marine Radio.

Two Tone FSK with 170Hz shift
100baud signalling rate
Tone frequencies 1700 = 0, 1870 = 1 (tone centre = 1785)
- compare with DSC: 1615 = 1, 1785 = 0 (tone centre = 1700, inverted shift)
Symbols are 10-bit words, 7 bit + 3 parity bits
Dotting pre-amble of alternating 1010….. 2 to 20 seconds depending on expected scan-group size
Same “symbol repeat after 4” RX/DX interleaving as DSC
Same phasing sequence as DSC
No overall Error Check Sum, unlike DSC

At its simplest a selcall transmission can be either:

Directed call to a specific address
1. Selcall = send a revertive signal over the air AND alert the remote operator. The FMT symbol = 120
2. Directed-Beacon = send revertive signal over the air, but do not alert remote operator. The FMT symbol = 123
99-beacon call to a group of addresses = all stations send revertive signal over the air, but do not alert remote operator. The 99-beacon call is a special form of a directed selcall, with the FMT symbol of 120 and the final two digits of the destination address = 99. Receiving decoders understand to treat the call as a special type of beacon call despite the FMT being 120 (Selcall)

The directed-beacon to a specific address will confirm if that station is reachable, without disturbing the operator.

The 99-beacon call confirms whether any station in the group are reachable - the group is “any station with the first two digits matching”. The address used for the 99-beacon call is XX99, where XX is the leading digits of the desired group. For example, a group stations 3610, 3602, 3603, 3654 would all respond to a 99-beacon call addressed to 3699

Jenal SC2 Mic

HF Selcall is widely used in Australia, and there is a large market for add-on Selcall devices (to convert non-selcall radios) there. One manufacturer of Selcall equipment is JENAL.

At the time of my first exploration of Selcall I found that the SC2 microphone seemed like the perfect solution. The SC2 had been out of production, but Jenal had just released a new batch and I bought TWO of them, allowing me to experiment in isolation, should I fail to find any other amateur stations suitably equipped.

SC2 Handbook

One SC2 microphone can be connected to a Xiegu G90 portable HF transceiver, capable of 20W pep, and the other SC2 can be connected to a home made 60m SSB transceiver, also capable of 20W PEP, at the main station.

Scanning

The SC2 is capable of controlling the transceiver to scan, waiting for incoming selcall dotting signals, when it will pause the scan to decode any selcall message and act upon it as appropriate. Scan will resume after a certain period. The simplest scanning method is to pulse the channel up or channel down line present on most ham-grade transceivers on the mic-connector and thus the radio will step through its memory channels looking for selcall signals.

Previous Selcall Activity

In previous periods of activity with Selcall I have managed a few contacts and QSOs. Mainly with two stations who were already equipped with Barrett or Codan radios which can use CCIR493 “out of the box”.

GM4WMM - with a Barrett 950. We successfully operated on a small set of predetermined channels in the 80m, 60m, 40m bands, scanning, and selecting the optimum channel using beacon calls.
F6EMT - with a Codan . Made several contacts on 20m, some of them while mobile, initiated as random Selcall QSOs.

For 2023 I hope to find some more Selcall-equipped stations willing to try some experiments.

Selcall Activity 2023

[✓ John Pumford-Green, 2023-04-30] ~~Attach SC2 to Xiegu G90~~
[✓ John Pumford-Green, 2023-04-30]~~Set up 60m homebrew radio & amplifier & attach SC2~~
[✓ John Pumford-Green, 2023-05-05]~~Install mobile whip on van for use with G90~~
[✓ John Pumford-Green, 2023-04-30]~~Make adaptor for IC-M710 to allow easy connection of SC2 in place of usual datamode interface, for access to more bands~~
Try to make contact with like minded experimenters for on-air tests

UPDATE — John Pumford-Green 30/04/23 16:57

When not otherwise engaged I'll leave my main station IC-M710 monitoring 14.343MHz or 18.163MHz with Selcall ID 3658. I may not be able to respond directly to any calls the Selcall will send revertives (at 50W) for successful selcall or beacon calls to 3658or for 99-beacon calls to 3699

For skeds please contact me by email - address at https://www.qrz.com/db/GM4SLV

I have re-enabled emails from the hf-link groups.io https://groups.io/g/hflink to see what's happening here - the only place where CCIR493 appears to be discussed/used.

Further Information

Blackcat Android app for generating various Selcalls, including Barrett/Codan

Code snippets

My Python2 Selcall TX encoder

selcal_functions.py

# CCIR 493-4 Selcal Symbol Generator / CPFSK Modulator
# Wire2waves Ltd
# March 2015
# with CW ID for use on Amateur Radio bands
 
version = "v0.2"
 
# Imports
import numpy
import pyaudio
import struct
import time
from math import *
 
# quick and dirty CW Ident
# words per minute
wpm = 20
# dot period
cwdit = 1.2 / wpm
# dash period
cwdah = cwdit * 3
 
w_amp = (2**15) - 1
 
# define the output audio stream for the main data
p = pyaudio.PyAudio()
cpfsk_stream = p.open(format=pyaudio.paInt16, channels=1, rate=9600, output=1)
 
# make a second stream for the Tune carrier & cw ident
pt = pyaudio.PyAudio()
tunestream = pt.open(format=pyaudio.paInt16, channels=1, rate=9600, output=1)
 
pc = pyaudio.PyAudio()
cwstream = pc.open(format=pyaudio.paInt16, channels=1, rate=9600, output=1)
 
# convert text to symbol value using dictionaries
fmt_symbol_dict = { "sel" : "120", "bcn" : "123" }
cat_symbol_dict = { "rtn" : "100"}
eos_symbol_dict = { "req" : "117" }
 
 
# list containing Phasing Symbols in DX/RX order. 
 
phasing_symbol = [ "125", "109", "125", "108", "125", "107", "125", "106", "125", "105", "125", "104" ]
 
# Instead of doing bit-twiddling to convert each symbol
# value to its 10-bit parity protected word, which involves padding to full 7-bits, counting zeros,
# reversing the bit order, shifting bits and "ORing" in the parity bits
# we just use a dictionary containing the conversion between symbol value and its 10-bit parity protected word
#
parity_table = { 
"00" : "0000000111", "01" : "1000000110", "02" : "0100000110", "03" : "1100000101", 
"04" : "0010000110", "05" : "1010000101", "06" : "0110000101", "07" : "1110000100",
"08" : "0001000110", "09" : "1001000101", "10" : "0101000101", "11" : "1101000100", 
"12" : "0011000101", "13" : "1011000100", "14" : "0111000100", "15" : "1111000011", 
"16" : "0000100110", "17" : "1000100101", "18" : "0100100101", "19" : "1100100100", 
"20" : "0010100101", "21" : "1010100100", "22" : "0110100100", "23" : "1110100011", 
"24" : "0001100101", "25" : "1001100100", "26" : "0101100100", "27" : "1101100011", 
"28" : "0011100100", "29" : "1011100011", "30" : "0111100011", "31" : "1111100010", 
"32" : "0000010110", "33" : "1000010101", "34" : "0100010101", "35" : "1100010100", 
"36" : "0010010101", "37" : "1010010100", "38" : "0110010100", "39" : "1110010011", 
"40" : "0001010101", "41" : "1001010100", "42" : "0101010100", "43" : "1101010011", 
"44" : "0011010100", "45" : "1011010011", "46" : "0111010011", "47" : "1111010010", 
"48" : "0000110101", "49" : "1000110100", "50" : "0100110100", "51" : "1100110011", 
"52" : "0010110100", "53" : "1010110011", "54" : "0110110011", "55" : "1110110010", 
"56" : "0001110100", "57" : "1001110011", "58" : "0101110011", "59" : "1101110010", 
"60" : "0011110011", "61" : "1011110010", "62" : "0111110010", "63" : "1111110001", 
"64" : "0000001110", "65" : "1000001101", "66" : "0100001101", "67" : "1100001100", 
"68" : "0010001101", "69" : "1010001100", "70" : "0110001100", "71" : "1110001011", 
"72" : "0001001101", "73" : "1001001100", "74" : "0101001100", "75" : "1101001011", 
"76" : "0011001100", "77" : "1011001011", "78" : "0111001011", "79" : "1111001010", 
"80" : "0000101101", "81" : "1000101100", "82" : "0100101100", "83" : "1100101011", 
"84" : "0010101100", "85" : "1010101011", "86" : "0110101011", "87" : "1110101010", 
"88" : "0001101100", "89" : "1001101011", "90" : "0101101011", "91" : "1101101010", 
"92" : "0011101011", "93" : "1011101010", "94" : "0111101010", "95" : "1111101001", 
"96" : "0000011101", "97" : "1000011100", "98" : "0100011100", "99" : "1100011011", 
"100" : "0010011100", "101" : "1010011011", "102" : "0110011011", "103" : "1110011010", 
"104" : "0001011100", "105" : "1001011011", "106" : "0101011011", "107" : "1101011010", 
"108" : "0011011011", "109" : "1011011010", "110" : "0111011010", "111" : "1111011001", 
"112" : "0000111100", "113" : "1000111011", "114" : "0100111011", "115" : "1100111010", 
"116" : "0010111011", "117" : "1010111010", "118" : "0110111010", "119" : "1110111001", 
"120" : "0001111011", "121" : "1001111010", "122" : "0101111010", "123" : "1101111001", 
"124" : "0011111010", "125" : "1011111001", "126" : "0111111001", "127" : "1111111000" 
}
 
cw_table = {
"A" : ".-",
"B" : "-...",
"C" : "-.-.",
"D" : "-..",
"E" : ".",
"F" : "..-.",
"G" : "--.",
"H" : "....",
"I" : "..",
"J" : ".---",
"K" : "-.-",
"L" : ".-..",
"M" : "--",
"N" : "-.",
"O" : "---",
"P" : ".--.",
"Q" : "--.-",
"R" : ".-.",
"S" : "...",
"T" : "-",
"U" : "..-",
"V" : "...-",
"W" : ".--",
"X" : "-..-",
"Y" : "--.-",
"Z" : "--..",
"1" : ".----",
"2" : "..---",
"3" : "...--",
"4" : "....-",
"5" : ".....",
"6" : "-....",
"7" : "--...",
"8" : "---..",
"9" : "----.",
"0" : "-----",
" " : "",
"/" : "-..-.",
"?" : "..--..",
"+" : ".-.-."
}
 
#####################
# function definitions
#
 
##############
#  Tone generators (not used for data, but for Tune and CW signals)
#
# Setting the "cspace" and "lspace" amplitudes (pwr) to non-zero
# will produce FSK-style CW, as used in Beacons etc,
 
def sine(frequency, length, rate):
    length = int(length * rate)
    factor = float(frequency) * (pi * 2) / rate
    return numpy.sin(numpy.arange(length) * factor)#
#
# Generate a carrier to allow Auto-ATU to re-tune when changing frequency
# reduced amplitude, 3 seconds 
#
def tune_carrier(pwr):
    frequency = 1785
    length = 3
    rate = 9600
    chunks = []
    chunks.append(sine(frequency, length, rate))
    chunk = numpy.concatenate(chunks) * (w_amp * pwr)
    tunestream.write(chunk.astype(numpy.int16).tostring())
 
def dash(pwr):
    frequency=1900
    length=cwdah 
    rate=9600
    chunks = []
    chunks.append(sine(frequency, length, rate))
    chunk = numpy.concatenate(chunks) *  (w_amp * pwr)
    cwstream.write(chunk.astype(numpy.int16).tostring())    
 
def dot(pwr):
    frequency=1900
    length=cwdit
    rate=9600
    chunks = []
    chunks.append(sine(frequency, length, rate))
    chunk = numpy.concatenate(chunks) *  (w_amp * pwr)
    cwstream.write(chunk.astype(numpy.int16).tostring())  
 
def cspace(pwr):
    frequency=1700
    length=cwdit
    rate=9600 
    chunks = []
    chunks.append(sine(frequency, length, rate))
    chunk = numpy.concatenate(chunks) *  (w_amp * pwr)
    cwstream.write(chunk.astype(numpy.int16).tostring())     
 
def lspace(pwr):
    frequency=1700
    length=cwdah
    rate=9600
    chunks = []
    chunks.append(sine(frequency, length, rate))
    chunk = numpy.concatenate(chunks) *  (w_amp * pwr)
    cwstream.write(chunk.astype(numpy.int16).tostring())      
#
#   
################################
 
def make_call(cw_table, call):
    callsign = ""
    for i in call:
        callsign += cw_table[i]
        callsign += "s"        
    return callsign
 
def cwid(call, pwr):
    callsign = make_call(cw_table, call)
    for i in callsign:
        if i == "-":
            dash(pwr)
            cspace(pwr)
        elif i == ".":
            dot(pwr)
            cspace(pwr)
        elif i == "s":
            lspace(pwr)
 
###########
 
 
# split a 4 digit Selcal into two 2-digit symbols
# resulting symbols are returned as a list
def sel_id_symbol(sel_id):
    sel_id_list = [(sel_id[i:i+2]) for i in range(0, len(sel_id), 2)]    
    return sel_id_list
 
 
# build the basic Call:
# Selcal messages are of the form:  "fmt to_id cat self_id eos eos eos"
 
def build_call(f_s, a_s, c_s, s_s, eos_s):
 
    sel_call = []
 
    sel_call.append(f_s)
 
    for i in a_s:
        sel_call.append(i)
 
    sel_call.append(c_s)
 
    for i in s_s:
        sel_call.append(i)
 
    sel_call.append(eos_s)
 
    sel_call.append(eos_s)
    sel_call.append(eos_s)
 
    return sel_call
 
 
 
# interleave the symbols into DX and RX sequence 
# at the same time convert between symbol value and
# 10-bit parity word by looking in the parity_table dictionary.
 
def interleave(parity_table, phasing, sel_list):
 
    symbol_count = len(sel_list)
 
    sel_dxrx = []
    # interleave the phasing sequence
    for p in range(0,12):
        sel_dxrx.append(parity_table[phasing[p]]) #dxrx
 
    # add dx and rx copies of the format symbol
    sel_dxrx.append(parity_table[sel_list[0]]) #dx
    sel_dxrx.append(parity_table[sel_list[0]]) #rx
 
    # add the DX copy of the the to_ID
    sel_dxrx.append(parity_table[sel_list[1]]) #dx
 
    # add another RX copy of the format symbol
    sel_dxrx.append(parity_table[sel_list[0]]) #rx
 
    # add the DX copy of the category symbol
    sel_dxrx.append(parity_table[sel_list[2]]) #dx
 
    # loop through the remaining symbols to add the RX and DX versions 
    for i in range(0,symbol_count-3):
        sel_dxrx.append(parity_table[sel_list[i]]) #rx
        sel_dxrx.append(parity_table[sel_list[i+3]]) #dx
 
    # add a final DX and RX copy of the EOS symbol
    sel_dxrx.append(parity_table[sel_list[-1]])
    sel_dxrx.append(parity_table[sel_list[-1]])    
 
    # sel_dxrx is a list of 10-bit words, as ones and noughts, for the complete message
    return sel_dxrx
 
 
# Make a 600-bit dotting period of alternating 1/0 in a string
 
# Selcal dotting periods often 6 seconds (and up to 20 seconds in some
# instances) to allow for capturing scanning radios. 
# We send 300 bits / 6 seconds for now, pending a decision to extend or reduce the dotting period.
 
# Append to the string each 10-bit interleaved word, to create a string of 
# ones and noughts.
 
# return a string of ones & noughts representing the complete message
 
def make_bitstream(sel_dxrx):
    sel_bitstream= "10"  * 300 # dotting
    for i in sel_dxrx:
        sel_bitstream += i
    return sel_bitstream
 
 
 
# DSC and Selcall use tone spacing and baud rate that prevents the use of 
# "Sunde's FSK" method to create glitch-less bit transitions.
#
# To minimize bandwidth it's necessary to use "Continuous Phase FSK" which
# has a smooth transition of the waveform at the bit boundary. The method used is time-consuming
# as we have to create each audio sample based on the phase-advance of each bit-period and 
# store them in a buffer before sending them out to the soundcard via PyAudio.
# 
# This function is courtesy of Bill Lionheart : billlionheart@gmail.com
#
# Make the CPFSK-modulated sample values, pack them into a list, and convert to a string 
# to feed PyAudio  
#
 
def modulate(fmsg, fcarrier, f0, f1, fsample, baud, amp):
 
    if amp > 1.0:
       amp = 1.0
 
    sel_amp =  (w_amp * amp)
 
    mlen = len(fmsg)
 
    mtime = mlen/baud  
 
    nsamp = int(round(fsample*mtime))
 
    deltaT = 1.0/fsample
 
    ph=0
 
    y = [0] * nsamp
 
    for i in range(nsamp): # i = sample number
 
        thisbit = int(floor((i/float(nsamp))* mlen)) 
 
        # "thisbit" is the index number of the data-bit being modulated,
        # the same data-bit is used for "the number of samples which occupy 1 bit period"
 
        if fmsg[thisbit]:
            f = f1 
        else:
            f = f0 
 
        # if this bit is a 1 then f = mark-freq, else f = space-freq
 
        ph +=  2*pi*(fcarrier + f)*deltaT
 
        # phase advances during sample period according the actual mark or space freq
        # when the bit changes between 1 and 0, the phase advance in deltaT is small, and
        # continuity in phase is achieved. The signal then starts to advance
        # in phase according to the new frequency appropriate the the bit (one or nought)
        #being sent.
 
        # reset phase to zero every 360 degrees
        if ph> 2*pi: 
            ph = ph - 2*pi
 
        y[i]=sel_amp*(sin(ph)) # y is an 8-bit value
        # y[i] is the current sample's amplitude - the "sin of current accumulated phase"
 
    wave_list = []
    for v in y:
        vp = struct.pack('h',v)
        wave_list.append(vp)
    wavestring = ''.join(wave_list)
 
    return wavestring
 
 
# Take the message to be sent and
# 1) interleave
# 2) make bitstream as a string
# 3) convert to list, for the CPFSK modulator function, 
# 4) calculate the sample values using the "modulate()" function
# 5) write the string of sample values to pyaudio
 
 
def transmit_sel(sel_call, pwr):
    #
    # 1) interleave the message and phasing DX and RX symbols together, and also convert to 10-bit parity words
    sel_dxrx = interleave(parity_table, phasing_symbol, sel_call) 
 
    # 2) create a string with the ones and noughts representing the full message
    sel_bitstream = make_bitstream(sel_dxrx)
 
    # 3) convert the string into a list, to feed the CPFSK modulator
    bitstream_list = [int(sel_bitstream[i:i+1]) for i in range(0, len(sel_bitstream), 1)]
 
    # 4) get a list of sample values from the CPFSK modulator
    #
    # arguments for modulate() : (source of message_bits(a list), f-centre, space_dev, mark_dev, sample_rate, baud_rate, amplitude)
    # returns a string of 8-bit signed values to feed PyAudio
 
    wave = modulate(bitstream_list, 1785, -85, +85, 9600, 100.0, pwr)
 
    # 5) make some noise...
 
    cpfsk_stream.write(wave)
 
    return

selcal_gui.py

# Wire2waves Ltd
# CCIR 493-4 Selcal Generator & Modulator
# Generic, non-TX GUI
 
 
from Tkinter import *
from selcal_functions import *
import threading
import Queue
import time
 
version = "v0.2"
 
 
class Application(Frame):
    def __init__(self, master):
        """ Initialize frame"""
        Frame.__init__(self, master)
        self.grid()
        self.create_widgets()
 
        # we manage the three sound-producing functions in Threads, run at startup but only produce
        # output when their Queues are set to "1"
        self.selqueue = Queue.Queue()
        self.tunequeue = Queue.Queue()
        self.cwqueue = Queue.Queue()
        self.tunequeue.put(0)
        self.selqueue.put(0)
        self.cwqueue.put(0)
        t1 = threading.Thread(target = self.tune)
        t1.setDaemon(True)
        t1.start()
        c1 = threading.Thread(target = self.send_cwid)
        c1.setDaemon(True)
        c1.start()
        d1 = threading.Thread(target = self.send_sel)
        d1.setDaemon(True)
        d1.start()
 
 
    def create_widgets(self):
 
        ###### 
        #
        # The Address Entry Fields
        self.to_l = Label(self, width = 15, text = "To ID", fg = 'red').grid(row = 0, column = 0, sticky = W)
        self.to_sel_id_e = Entry(self, width = 10, fg = 'red')
        self.to_sel_id_e.grid(row = 0, column = 1, padx = 5, pady = 5, sticky = W)
        self.to_sel_id_e.insert(0, "3922")
 
 
        self.from_l = Label(self, width = 15, text = "Self ID", fg = 'blue').grid(row = 1, column = 0, sticky = W)
        self.from_sel_id_e = Entry(self, width = 10, fg = 'blue')
        self.from_sel_id_e.grid(row = 1, column = 1, padx = 5, pady = 5, sticky = W)
        self.from_sel_id_e.insert(0, "3921")
 
        ###################
        #
        # The "Format" selection radio buttons
        self.fmt = StringVar()
        self.fmt_l = Label(self, width = 15, text = "Format").grid(row = 5, column = 0, sticky = W)
        self.sel_r = Radiobutton(self, text = "Sel", variable = self.fmt, value = "sel")
        self.sel_r.grid(row = 5, column = 1, sticky = W)
        self.bcn_r = Radiobutton(self, text = "Bcn", variable = self.fmt, value = "bcn")
        self.bcn_r.grid(row = 5, column = 2, sticky = W)
        #self.fmt_e = Entry(self, width = 10, fg = 'blue')
        #self.fmt_e.grid(row = 5, column = 1, padx = 5, pady = 5, sticky = W)
        #self.fmt_e.insert(0, "120")
 
        #
        # click the "SEL" radio button
        self.sel_r.invoke()
        #
        ########
 
        ######
        #
        # The "Category" selection radio buttons
 
        self.cat = StringVar()
 
        self.cat_l = Label(self, width = 15, text = "Category").grid(row = 6, column = 0, sticky = W)
        self.saf_r = Radiobutton(self, text = "Routine", variable = self.cat, value = "rtn")
        self.saf_r.grid(row = 6, column = 1, sticky = W)
        #self.cat_e = Entry(self, width = 10, fg = 'blue')
        #self.cat_e.grid(row = 6, column = 1, padx = 5, pady = 5, sticky = W)
        #self.cat_e.insert(0, "100")
 
 
        # For selcal we may require other categories, but at present only "Routine" is used
        #self.urg_r = Radiobutton(self, text = "Urgent", variable = self.cat, value = "urg")
        #self.urg_r.grid(row = 6, column = 2, sticky = W)
        #self.dis_r = Radiobutton(self, text = "Distress", variable = self.cat, value = "dis")
        #self.dis_r.grid(row = 6, column = 3, sticky = W)
 
        # click the "Safety" radio-button
        self.saf_r.invoke()
        #
        ########
 
        ####
        #
        # The "EOS" selection radio buttons
 
        self.eosv = StringVar()
        self.eos_l = Label(self, width = 15, text = "EOS").grid(row = 9, column = 0, sticky = W)
        self.req_r = Radiobutton(self, text = "REQ", variable = self.eosv, value = "req")
        self.req_r.grid(row = 9, column = 1, sticky = W)
        #self.eos_e = Entry(self, width = 10, fg = 'blue')
        #self.eos_e.grid(row = 9, column = 1, padx = 5, pady = 5, sticky = W)
        #self.eos_e.insert(0, "117")
 
        # leave these in case other EOS symbols would be useful in the future 
        #self.ack_r = Radiobutton(self, text = "ACK", variable = self.eosv, value = "ack")
        #self.ack_r.grid(row = 9, column = 2, sticky = W)
 
        #self.eos_r = Radiobutton(self, text = "EOS", variable = self.eosv, value = "eos")
        #self.eos_r.grid(row = 9, column = 3, sticky = W)
 
        # click the "REQ" radio button
        self.req_r.invoke()
        #
        ###########
 
 
        ###########
        #
        # The "do something" buttons
 
        self.go_b = Button(self, text = "Send Selcal", command = self.selqueue_on)
        self.go_b.grid(row = 10, column = 0, sticky = W+E)
 
        self.tune_b = Button(self, text = "Tune", command = self.tunequeue_on)
        self.tune_b.grid(row = 13, column = 0, sticky = W+E)
 
        self.cw_call_e = Entry(self)
        self.cw_call_e.grid(row = 14, column = 1, columnspan = 2)
        #
        # The CW Text is pre-set, but can be edited as required on the GUI
        self.cw_call_e.insert(0, "   de GM4SLV   ")
 
        self.cw_b = Button(self, text = "Send CW ->", command = self.cwqueue_on)
        self.cw_b.grid(row = 14, column = 0, sticky = W+E)
 
        ######
        #
        # The display of Selcal Symbols
        #
 
        self.sel_title = Label(self, text = "Sending Selcal Symbols: " , fg = 'blue').grid(row = 16, column = 0)
 
        sel_call_f = Frame(self, relief = GROOVE, borderwidth = 2, pady = 5)
        sel_call_f.grid(row = 17, column = 0, columnspan = 5, padx = 5, pady = 5, sticky = W+E)
 
 
        self.sel_label = StringVar()
        self.sel_l = Label(sel_call_f, textvariable = self.sel_label, fg = 'blue', height = 2, wraplength = 350, anchor = W)
        self.sel_l.grid(row = 0, column = 0)
        #
        #####
 
 
    # When a Tune is required we call tunequeue_on() which puts a "1" into the queue.
    # The queue is read by tune() which is running constantly (while True:) in a thread. 
    # If a "1" is found the tune_carrier() function is triggered
    # then tunequeue_off() will put a "0" in the queue which will inhibit any further
    # tune signals. 
 
    # Since the Tune, CWID and Selcal Transmit all run in their own threads, with their own queues
    # it's possible to do all three functions at once, and still retain an active GUI
    # this may not be "the right way" to do this, but it works...
 
    def tunequeue_on(self):
        self.tunequeue.put(1)
 
    def tunequeue_off(self):
        self.tunequeue.put(0)
 
 
    def tune(self):
 
        while True:
            t_on = self.tunequeue.get()
            if t_on == 1:   
                pwr = 0.7
                tune_carrier(pwr)
                self.tunequeue_off()
 
 
    def cwqueue_on(self):
        self.cwqueue.put(1)
    def cwqueue_off(self):
        self.cwqueue.put(0)
 
    def send_cwid(self):
        while True:
            c_on = self.cwqueue.get()
            if c_on == 1:
                pwr = 0.7
                call = self.cw_call_e.get().upper()
                cwid(call, pwr)
                self.cwqueue_off()
 
    def selqueue_on(self):
        self.selqueue.put(1)
    def selqueue_off(self):
        self.selqueue.put(0)
 
    def send_sel(self):
 
        while True:   
            go = self.selqueue.get()
            if go == 1:
                a_sel_id = self.to_sel_id_e.get()
                s_sel_id = self.from_sel_id_e.get()
                fmt = self.fmt.get()
                cat = self.cat.get()
                eos = self.eosv.get()
                pwr = 0.7
 
                # restrict to 4-digit 493-4
                if len(a_sel_id) != 4:
                    continue
                if len(s_sel_id) != 4:
                    continue
 
                # convert the format, category and eos to the appropriate symbol values
                fmt_symbol = (fmt_symbol_dict[fmt])
                #fmt_symbol = self.fmt_e.get()
 
                cat_symbol = (cat_symbol_dict[cat])
                #cat_symbol = self.cat_e.get()
 
                eos_symbol = (eos_symbol_dict[eos])
                #eos_symbol = self.eos_e.get()
 
                # convert the 4-digit selcal IDs into two 2-digit symbols
                a_symbol = sel_id_symbol(a_sel_id)
                s_symbol = sel_id_symbol(s_sel_id)
 
                # build the call by joining the symbol values into a list
                sel_call = build_call(fmt_symbol, a_symbol, cat_symbol, s_symbol, eos_symbol)
 
                #we want the basic selcal message returned to us, to display on the GUI
                self.sel_label.set(sel_call)
 
                # turn the selcal queue off to stop further transmissions
                self.selqueue_off()
 
                # then we pass the selcal list and required "power" into "transmit_sel() which does the rest...
                transmit_sel(sel_call, pwr) 
 
 
 
if __name__ == '__main__':
    root = Tk()
 
    root.geometry("350x350+10+10")
    root.title("GM4SLV HF CCIR 493-4 Selcal " + version)
    root.resizable(0, 0)
    app = Application(root)
 
 
    root.mainloop()

— John Pumford-Green 29/04/23 11:42

Last Modified : 04/06/26 07:39 BST

radio, selcall

CW 2023

anonymous@undisclosed.example.com (Anonymous) — Thu, 04 Jun 2026 18:19:11 +0000

←Radio Topics

CW 2023

CW always was my main mode of operation

I've spent a lot of time with Digimodes (mainly on 60m) and recently even tried SSB on the HF bands (and might use SSB more often in future) but CW is really where I feel happiest. For a long time it was my only mode of operation on HF. Even now, at times when I'm out of practice, and my sending gets a bit wobbly, I feel comfortable with CW. There's something magical about communicating over the airwaves without speaking, without typing, just using a series of dits and dahs controlled by your own hand and turned from sound into meaning in your own brain.

When I started my current (Summer 2023) resurgence of interest in radio I thought I'd push myself to use SSB, to speak to people, and this would be the “novelty” I was looking for to kick start my interest in the hobby.

After a few weeks of getting things up and running I find I'm gravitating towards the CW end of the bands again, I've wired up all my keys, including my Vibroplex bug which has seen very little use on the air since I bought it. I did use it a few times in 2021 during a previous spell of on-air activity, but I let it lie dormant for the next 2 years, until NOW.

Let the CW-fest begin.

Current Setup

Vibroplex “Presentation” bug : Serial No 198474, Plate “Patented 833 Broadway” (D6 Plate). The Serial Number list ww7p-serial-number-list.pdf indicates 1957
Hi-Mound HK-708 (the same one I've had since 1982)
GPO brass key
“Russian army” key
Vibroplex “Champion” bug : Serial No 211617, Plate “Patented 833 Broadway” (D6 Plate), date 1960

Icom IC-7200 main HF radio
Icom IC-706 second HF

Plans

No Iambic/electronic keyers

I enjoy straight key sending and have occasionally used my Vibroplex on the air for faster QSOs than I'm able to manage with a straight key. The bug is taking some time to feel comfortable, and all I can do is practice, practice and more practice.

I'll try to do most of my QSOs on the bug, currently set at 18wpm (according to my spots on RBN) which is a comfortable speed for me at the moment, both for sending and receiving. I had my first “new” CW QSO using the bug today (June 12th) on 40m with Lada, OK2PAY who I remember working before, some years ago. In fact here's a video of the QSO on my You Tube OK2PAY 30m CW - the QSO was 16 July 2016 on 30m…. wow, 7 years ago!

I've re-joined the FISTS CW club with my old member number 17686 - and I see my SKCC old membership number is still listed as 3214. I'll try to take part in more activities by these clubs.

Have QSOs → rag-chews, rubber-stamp, all sorts…..

I hope to get enough air-time and enjoyment that perhaps I can justify a new key or even a new bug (I have been looking in wonder at the Begali Intrepid )……

Update 23/6/23 : New (to me) bug…. 1960 Vibroplex Champion from eBay Vibroplex Champion Bug

Receive Practice

One of my favourite sources of material for “head copy” practice is the ARRL's Code Practice Archive

http://www.arrl.org/code-practice-files

Here you can download MP3 files of their Code Practice recordings, which are extracts from QST magazine, sent at various speeds from 5 wpm to 40 wpm.

I have put a lot of the 25, 30, 35 and 40 wpm files on a USB stick to play in the van and on my phone to play whenever/wherever.

I find it is good to just let the CW flow and to grasp as much as you can, in bursts, and then let the “meaning” sink in - even when you miss the odd letter or word. In “conversational” CW it's best to let go of mistakes and just concentrate on making sense of what you're hearing. Exact “carbon copy” is only needed for formal messages (telegrams, RAYNET etc). Just letting the CW flow in through the ears and the “meaning” of the message condense in your brain makes you feel more comfortable about glitches and missing parts. In a QSO nobody is going to know how much you actually copied, as long as you get the important bits - name, QTH etc - which are usually sent more than once. If you don't respond to a question (because you missed it being asked) they can always ask again, and assume you just forgot. The key is to not care too much about 100% accurate copy, and the more you have QSOs, the easier it becomes and the more you copy, a virtuous circle.

— John Pumford-Green 12/06/23 13:22

Further Information

The Art and Skill of Radio Telegraphy : tasrt.pdf
Articles by Tom McElroy (thanks to Ian IK4EWX)

radio, cw

DMR and DV Modes

anonymous@undisclosed.example.com (Anonymous) — Thu, 04 Jun 2026 06:59:41 +0000

←Radio Topics

DMR and DV Modes

Hotspots

DVMega Simplex hotspot
MMDVM_HS_Hat Simplex hotspot
MMDVM_HS_Dual_Hat Duplex Hotspot

Date	Hotspot	Colour	Frequency	Config	Location	Software	Comments
25/03/24	DVmega	N/A	434.000MHz	wpsd_config_fusion_2024-mar-26.zip	Home	WPSD	YSF Single mode
17/03/24	MMDVM	Red	438.800MHz		Mobile	Pi-Star	2-DMR Network
25/03/24	Duplex MMDVM	Green	439.950MHz / -9.9MHz	pi-star_config_repeater_2024-mar-26.zip	Home	Pi-Star	2-DMR Network

https://brandmeister.network/?page=device&id=235442904

Brandmeister Details

On arrival (25/3/24) the Dual-Hat board had the wrong firmware (MMDVM_HS_HAT) and would not operate correctly as a duplex/two-timeslot hotspot.
Pi-Star has capability to upgrade attached MMDVM firmware, but attempts to load MMDVM_HS_Dual_Hat repeatedly failed
The firmware upload function was locked but unlocking was a simple matter of solder-bridging the pads of “JP1” on the MMDVM board.
Pi-Star Firmware upgraded successfully to MMDVM_HS_Dual_Hat v1.6 and duplex/two timeslot functionality was successful

Radios

— John Pumford-Green 17/03/24 23:34

Further Information

DMR Dashboards

Phoenix A	MMDVM Repeaters	http://dvsph-a.dvsph.net/
Phoenix F	Hotspots	http://phoenix-f.opendmr.net/ipsc/
Phoenix K	Hytera / Motorola Repeaters	http://dvsph-k.dvsph.net/ipsc/
Phoenix M	Personal Repeaters	http://phoenix-m.opendmr.net/ipsc/
GM4SLV	My Hotspot	http://gm4slv.plus.com:28080/
GB7HT	Ashington / G4NAB	http://gb7ht.ddns.net:8080/

radio, dv, pistar, ysf, nxdn, dmr

DMR HotSpots

anonymous@undisclosed.example.com (Anonymous) — Thu, 04 Jun 2026 18:25:04 +0000

←Radio Topics

DMR HotSpots

Pi-Star and DVMega or MMDVM_HS Raspberry Pi “hat”

Currently connected to Brandmeister directly.

Previously it has used DMRGateway to control connections to three DMR networks:

Brandmeister
Phoenix / DMR+
TGIF

Update 3/10/22

Hotspot active again, using DMR Gateway and 3 networks:

DMR Gateway Config

[General]
RptAddress=127.0.0.1
RptPort=62032
LocalAddress=127.0.0.1
LocalPort=62031
RuleTrace=0
Daemon=1
Debug=0
RFTimeout=20
NetTimeout=20

[Log]
DisplayLevel=0
FileLevel=1
FilePath=/var/log/pi-star
FileRoot=DMRGateway

[Voice]
Enabled=1
Language=en_GB
Directory=/usr/local/etc/DMR_Audio

[Info]
Enabled=0
RXFrequency=438800000
TXFrequency=438800000
Power=1
Latitude=60.2885
Longitude=-1.4252
Height=0
Location="Shetland"
Description="UK"
URL=https://www.qrz.com/db/GM4SLV

[XLX Network]
Startup=950
Enabled=0
File=/usr/local/etc/XLXHosts.txt
Port=62030
Password=passw0rd
ReloadTime=60
Slot=2
TG=6
Base=64000
Relink=60
Debug=0
Id=2354429
UserControl=1

[DMR Network 1]
Enabled=1
Address=2341.master.brandmeister.network
Port=62031
TGRewrite0=2,9,2,9,1
PCRewrite0=2,94000,2,4000,1001
TypeRewrite0=2,9990,2,9990
SrcRewrite0=2,4000,2,9,1001
PassAllPC0=1
PassAllTG0=1
PassAllPC1=2
PassAllTG1=2
Password="<Brandmeister Hotspot Password"
Debug=0
Id=<DMRID and SSID>
Name=BM_2341_United_Kingdom
Location=1

[DMR Network 2]
Enabled=1
Address=78.129.135.43
Port=55555
TGRewrite0=2,8001,2,1,999
TGRewrite1=2,82000,2,2000,999
TGRewrite2=2,823000,2,23000,999
TGRewrite3=2,89900,2,9900,99
PCRewrite0=2,84000,2,8009,1
PCRewrite1=1,85057,2,5057,1
Password="PASSWORD"
Debug=0
Id=235442901
Name=DMR+_IPSC2-PhoenixF
Location=0
Options="StartRef=4000;UserLink=1;TS1_1=235;"

[DMR Network 3]
Enabled=0
Name=HBLink
Address=1.2.3.4
Port=5555
TGRewrite=2,11,2,11,1
Password="PASSWORD"
Location=0
Debug=0
TGRewrite0=2,11,2,11,1

[DMR Network 4]
Enabled=1
Name=TGIF
PCRewrite1=1,4009990,1,9990,1
PCRewrite2=2,4009990,2,9990,1
TGRewrite1=1,4000001,1,1,999999
TGRewrite2=2,4000001,2,1,999999
SrcRewrite1=1,9990,1,4009990,1
SrcRewrite2=2,9990,2,4009990,1
SrcRewrite3=1,1,1,4000001,999999
SrcRewrite4=2,1,2,4000001,999999
Address=tgif.network
Password=<TGIF Hotspot Access Key>
Port=62031
Location=0
Debug=0
Id=<DMRID and SSID>

[GPSD]
Enable=0
Address=127.0.0.1
Port=2947

[APRS]
Enable=1
Address=127.0.0.1
Port=8673
Description=APRS for DMRGateway
Suffix=DMR

[Dynamic TG Control]
Enabled=1
Port=3769

Fldigi Parrot

anonymous@undisclosed.example.com (Anonymous) — Thu, 04 Jun 2026 06:39:56 +0000

←Radio Topics

Fldigi Parrot

Experimental HF Digi-mode message-relay system using Fldigi and Python

Work in progress

Uses xml-rpc in python to communicate with fldigi and read the incoming RX Text.

When a particular text sequence is received (ZCZC CALL CALL) to trigger the “parrot” function, the RX text is then read searching for an end of message string (…end). When this is found the full message is then re-transmitted, with self-identification added to ensure it is clear which station is the source of the message and which is the source of the relay.

Transmitter control via RS232 / NMEA (for an IC-M710 marine HF transceiver) is also included to allow for remote commands to change frequency to be handled. Fldigi does the rig control (via its own hamlib configuration). Fldigi is told what we want the radio to do via xml-rpc rather than have direct control ourselves.

Monitoring

A web-page is provided that shows the Fldigi receive text, in almost real time at:

~~Fldigi RX Text~~

and another shows the parrot activity:

~~Fldigi Parrot~~

Software

The python scripts to run these functions are run within a tmux session which is set up with the following script:

tmux script

fldigi_xml.sh

#!/bin/sh
 
session="Shack"
 
tmux start-server
 
tmux new-session -d -s $session 
 
tmux rename-window "fldigi"
 
tmux selectp -t 0
tmux send-keys "python2 ./rx_buf.py" C-m
 
 
 
tmux selectp -t 0
tmux splitw -h -p 50
tmux send-keys "python2 ./parrot_flmsg.py" C-m
 
tmux selectp -t 1 
tmux attach-session -t $session

The python scripts

rx_buf.py
parrot_flmsg.py
flfn.py

are as follows:

rx_buf.py

rx_buf.py reads the Fldigi RX Buffer and provides the online web page to allow remote observation of what is being received.

rx_buf.py

import xmlrpclib
import time
import os
 
s = xmlrpclib.ServerProxy("http://192.168.21.107:7362")
rx_text = ""
n = 0
index = 0
count = 0
 
def get_status():
 
    try:
        status = s.main.get_status1()
    except:
        status = "Fldigi Offline"
    return status
 
def get_mode():
 
    try:
        mode = s.modem.get_name()
    except:
        mode = "Fldigi Offline"
    return mode
 
def get_freq():
    try:
        freq = s.main.get_frequency()
        carrier = s.modem.get_carrier()
        centre = (float(freq) + int(carrier))/1000
    except:
        centre = 0.0
    return centre
 
def write_file(text):
    print "in write_file() with ", text
    text_asc = "".join(x for x in text if (ord(x) > 31 and ord(x) < 128) or ord(x) == 13 or ord(x) == 10 or ord(x) == 9)
    filename = r'/var/www/html/pages/gm4slv_fldigi.txt'
    f = open(filename, 'a+')  # a+ is "append to file, create it if it doesn't exist"
    f.write(text_asc)
    f.close()
    return
 
def stamp_file():
    mode = get_mode()
    centre = get_freq()
    status = get_status()
    timenow = time.strftime("*** Time Stamp : %Y-%m-%d %H:%M :  ", time.gmtime(time.time()))
    #print mode
    write_file("\r\n\n%s *** Modem : %s : Centre Freq : %.3f *** SNR : %s \r\n\n" % (timenow, mode, centre, status))
 
def tail(n):
    filename = r'/var/www/html/pages/gm4slv_fldigi.txt'
    tailfile = r'/var/www/html/pages/gm4slv_tail.txt'
    fin = open(filename, 'r')
    list = fin.readlines()
    fin.close()
    tail_list = list[-n:]
    fout = open(tailfile, "w")
    fout.writelines(tail_list)
    fout.close()
 
 
while True:
    '''
    try:
        rx_length = s.text.get_rx_length()
        rx_text = str(s.text.get_rx(index,rx_length - index))
        index = rx_length
    except:
        rx_text = ""
    '''
    rx_length = s.text.get_rx_length()
    print "rxl ", rx_length
    print "index ", index
    print "getting %d, %d" % (index, rx_length - index)
    rx_text = str(s.text.get_rx(index,rx_length - index))
    index = rx_length
    if rx_text == "empty rx buffer!":
        rx_text = ""
    #s.text.clear_rx()
    #os.system('cls' if os.name == 'nt' else 'clear')
    print  rx_text
 
 
 
    write_file(rx_text)
    tail(100)
 
    count += 1
 
    if count == 180:
        # hourly 180 * 20 secs = 3600 secs = 60 mins
        stamp_file()
        count = 0
    time.sleep(20)

parrot_flmsg.py

parrot_flmsg.py handles the message-relay functions.

Recent changes were made to handle the longer formal message formats of flmsg.

The parrot also provides some simple remote control of the HF transceiver's frequency and power level via QSY? and PWR? commands.

parrot_flmsg.py

#
#######
##  test file
#
 
import xmlrpclib
import time
import os
#import subprocess
 
import flfn
 
s = xmlrpclib.ServerProxy("http://shack:7362")
 
 
rx_text = []
zc_flag = 0
nn_flag = 0
message_time = 0
 
qsy_flag = 0
qsy_time = 0
 
mycall = "GM4SLV"
 
info = "GM4SLV INFO\nTest Relay\nIC-M710 50W\nInverted-L\n"
help_text = "Usage : \nZCZC\nRELAY_CALL FROM_CALL [ INFO? | HELP? | TO_CALL ]\nNNNN"
 
### remove old crud
#
s.text.clear_rx()
 
flfn.do_qsy(5366.5)
 
def write_file(text):
    filename = r'/var/www/html/pages/parrot_log.txt'
    f = open(filename, 'a+')
    f.write(text)
    f.close()
 
def parse_message(text):
    global qsy_flag
    global qsy_time
    #print "Parsing : ", text
    header_line=text.split('\n')[0]
    message_text = "\n".join(text.split('\n')[1:])
    print "Header Line :\n", header_line
    print "Message Text : \n", message_text
 
    calls_list = header_line.split()
 
    if len(calls_list) > 1:
        if len(calls_list) < 5:
 
            qsy_time = time.time()
 
            print "Calls List ", calls_list
 
            relay_call = calls_list[0].upper()
 
            print "Relay call ", relay_call
 
            from_call = calls_list[1].upper()
 
            if len(calls_list) > 2:
                to_call = calls_list[2].upper()
            else:
                to_call = "ECHO"
 
            print "From ",from_call
 
            print "To ",to_call
 
            user = call_asc(from_call)
 
            target = call_asc(to_call)
 
            if len(calls_list) == 4:
                command = calls_list[3]
 
            message = "\n".join(text.split('\n')[1:])
 
            if target == "INFO?":
                target = user
                user = "ECHO"
                message = info
 
            if target == "PWR?":
                pwr = flfn.do_pwr(command)
                target = "BOGUS"
                user = "BOGUS"
                message = "New Power preset %s" % (command)
 
            if target == "QSY?":
                qsy = flfn.do_qsy(command)
                target = "BOGUS"
                user = "BOGUS"
                message = "New Freq %s" % (command)
                #print "command was ", command
                if command != "HOME":
                    qsy_flag = 1
                    print "set qsy_flag ", qsy_flag
                    #print qsy_time
                else:
 
                    qsy_flag = 0
                    print "reset qsy_flag ", qsy_flag    
 
            if from_call == "HELP?" or target == "HELP?":
                target = user
                user = "ECHO"
                message = help_text
 
            if relay_call == mycall:
                return(user,target,message)
 
            else:
                print "Wrong Relay Call"
                return("BOGUS","BOGUS","Not for Me")
 
        else:
            print "Header too long"
            return("BOGUS", "BOGUS", "Too Long")
    else:
        print "Header too short"
        return("BOGUS", "BOGUS","Too Short")
 
def call_asc(call):
    call_asc = "".join(x for x in call if (ord(x) > 46 and ord(x) < 58) or (ord(x) > 62 and ord(x) < 91))
    return(call_asc)
 
 
 
def qsp(text, snr):
    print "\nQSP triggered"
 
    timenow = time.strftime("*** Time Stamp : %Y-%m-%d %H:%M:%S :  ", time.gmtime(time.time()))
 
    user,target,message=parse_message(text)
    print "Message : \n",message    
    if user == "BOGUS":
        print "Ignoring"
        write_file("\n%s\nNOT RELAYED\n%s" % (timenow, text))
        #subprocess.call("./log.sh")
        s.text.clear_rx()
 
        return
 
    time.sleep(10)
    s.text.clear_rx()
 
    print "PTT ON"
 
    timemsg = time.strftime("%H:%M:%S ", time.gmtime(time.time()))
    s.main.tx()
    s.text.add_tx("\n"+timemsg+"\nTo "+target+" from "+user+" via GM4SLV ("+snr+")\n\n"+message+"\n\n\n"+target+" de "+user+" via GM4SLV kn \n  ^r")
 
    timenow = time.strftime("*** Time Stamp : %Y-%m-%d %H:%M:%S :  ", time.gmtime(time.time()))
    timemsg = time.strftime("%H:%M:%S ", time.gmtime(time.time()))
 
    modem = s.modem.get_name()
    car = s.modem.get_carrier()
    f = s.main.get_frequency()
    rfc = (f + car) / 1000
 
    write_file("\n%s\n%s (%s)  Message Relayed on %0.1f for : %s\n%s\n====================\n" % (timenow, modem, snr, rfc, user, text))
    #subprocess.call("./log.sh")
 
    return
 
 
def watchdog():
    #print "In Watchdog ", qsy_flag
    if qsy_flag == 1:
        print "We were QSY'd"
        delta_t = time.time() - qsy_time
        print delta_t
        if delta_t > 300:
            print "Timeout"
            qsy_end = "GM4SLV GM4SLV QSY? HOME"
            parse_message(qsy_end)
            timenow = time.strftime("*** Timeout : %Y-%m-%d %H:%M:%S :  ", time.gmtime(time.time()))
            write_file("\n%s : Returning to HOME channel\n" % (timenow))
    else:
        return
 
 
while True:
    try:
        rx_length = s.text.get_rx_length()
   #     print "rx_length ",rx_length
        for l in range(rx_length-2000, rx_length):
            rx = str(s.text.get_rx(l,1))
            rx_text.append(rx)
            for i in range(len(rx_text)):
                if rx_text[i] == "C" and rx_text[i-1] == "Z" and rx_text[i-2] == "C" and rx_text[i-3] == "Z":
 
                    if not zc_flag:
                        print "Found ZCZC...."
 
                        modem = s.modem.get_name()
                        if modem != "RTTY":
                            stat1 = s.main.get_status1()
                        else:
                            stat1 = s.main.get_status2()
 
                    zc_flag = 1
                    zc_index = i+2
 
                if rx_text[i] == "d" and rx_text[i-1] == "n" and rx_text[i-2] == "e" and rx_text[i-3] == " " and rx_text[i-4] == "." and rx_text[i-5] == "." and rx_text[i-6] == ".":
                    if not nn_flag and zc_flag:
                        print "Found end"
                    nn_flag = 1
                    nn_index = i-3
            text =  ''.join(rx_text)
 
        if zc_flag == 1:
 
            print "found start... waiting for end  ", message_time
            if message_time < 300:
                message_time += 1
            else:
                print "Timeout waiting"
                s.text.clear_rx()
                message_time = 0
                rx_text= []
                zc_flag = 0
                nn_flag = 0
 
        else:
            rx_text=[]
 
 
        if zc_flag == 1 and nn_flag == 1 : # message complete
            print "Message complete"
            #print "zc_index %d, nn_index %d" % (zc_index, nn_index)
            #print "Text  %s " % (rx_text[zc_index:nn_index])
            if zc_index < nn_index:
                message_time = 0
                print "Index correct"
                message = ''.join(rx_text[zc_index:nn_index+8])
                print "Raw Message ", message
                zc_flag = 0
                nn_flag = 0
 
                message_asc = "".join(x for x in message if (ord(x) > 31 and ord(x) < 128) or ord(x) == 13 or ord(x) == 10 or ord(x) == 9)
                rx_text = []
 
                qsp(message_asc, stat1)
 
 
            else:
                rx_text = []
                zc_flag = 0
                nn_flag = 0
 
    except:
        rx_text = []
 
 
    watchdog()
    time.sleep(2)

flfn.py

flfn.py is a helper module of functions to communicate with fldigi using xml-rpc.

flfn.py

import xmlrpclib
import time
 
s = xmlrpclib.ServerProxy("http://shack:7362")
 
 
def do_qsy_tune(ttime):
    while s.main.get_trx_status() != "rx":
        trx = s.main.get_trx_status()
        print "starting while ",trx
        #s.main.rx()
        time.sleep(1)
 
    s.main.tune()
    time.sleep(ttime)
    trx = s.main.get_trx_status()
    print "tune? ",trx
    while s.main.get_trx_status() != "rx":
        trx = s.main.get_trx_status()
        print "ending while ",trx
        s.main.rx()
        time.sleep(1)
    trx = s.main.get_trx_status()
    print "final status ",trx
    return
 
def fld_qsy():
    cur_modem_carrier = s.modem.get_carrier()
    cur_dial_freq = s.main.get_frequency()
    new_dial_freq = (cur_dial_freq + cur_modem_carrier - 1500)
    s.modem.set_carrier(1500)
    s.main.set_frequency(new_dial_freq)
    return
 
def do_qsy(freq):
    if freq == "HOME":
        print "in do_qsy with HOME"
        do_home()
        time.sleep(2)
        do_qsy_tune(3)
        do_home()
        return freq
    else:
        print "in do_qsy with ", freq
        s.main.set_frequency(float(freq)*1000)
        s.modem.set_carrier(1500)
 
        do_qsy_tune(3)
        return freq
 
def do_reverse():
    s.main.toggle_reverse()
    return
 
def do_rxid():
    s.main.toggle_rsid()
    return
 
def do_txid():
    s.main.toggle_txid()
    return
 
def do_home():
    s.main.run_macro(14)
    return
 
def do_pwr(pwr):
    if pwr == "1":
 
        s.main.run_macro(20)
    elif pwr == "2":
        s.main.run_macro(21)
    elif pwr == "3":
        s.main.run_macro(22)
    elif pwr == "4":
        s.main.run_macro(23)
    else:
        pass
    return

Parrot Operation

Basic overview

To trigger a message relay you need to send the following format of text:

ZCZC GM4SLV <YOURCALL> (replacing <YOURCALL> with your actual callsign)

This is the start of message trigger.

Then type/paste/otherwise send your message-to-be-relayed.

To end the message send:

… end

If you are using flmsg to to create and send the message it will send the correct end of message string … end itself, otherwise you need to add it manually.

After a short delay, if successful, you should hear/see your message being relayed.

Further examples of operation

add screenshots of relaying in operation

A simple “ECHO” relay

Page Updated: 04/06/26 07:39 BST

radio, fldigi, python

K2 2023

anonymous@undisclosed.example.com (Anonymous) — Thu, 04 Jun 2026 18:22:16 +0000

←Radio Topics

K2 2023

Building an Elecraft K2

Background

I built a K2 several years ago (2005 or 2006?) and have fond memories of the building process. Unfortunately I felt the need to sell it some years later, and have regretted this ever since.

I recently discovered that Elecraft still produce and sell K2 kits - although with occasional hold ups in supply due to the global problems of parts procurement. This discovery made me keen to build myself another one, and not to ever contemplate selling it. My first one had several modules added

Auto ATU
160m/RX antenna port
60m module
SSB module

This time around I plan on only adding the 160m/RX antenna module - the 60m module would have been nice but is now discontinued, and I don't see any value in the Auto ATU or SSB module for how I expect to use the K2 - in the shack, CW only.

Order

I ordered the K2 kit and 160m module today, July 27th 2023. I'm now waiting to hear about a likely shipping date. Hopefully it'll arrive before the winter, as I'd like to build it as an autumn/winter project - with a view to using it for Straight Key Night or G-QRP Winter Sports.

Progress

I plan to make notes here of the build process, and also to make some You Tube videos of the main milestones & test and alignment process. And of course of the first QSO.

— John Pumford-Green 27/07/23 23:25

Order Cancelled

After waiting for over 3 months, and still no sign of the K2 being available, I decided for various reasons to cancel the K2 order. I can't justify the expense and can find more important uses for both the money and for the time it would take to build a K2.

If Elecraft make K2 kits available sometime later, in 2024, I may consider ordering one at that time.

— John Pumford-Green 09/11/23 08:06

Further Information

https://elecraft.com/collections/full-kits-1/products/k2-the-classic-hf-transceiver-full-kit

radio, k2

Netradio Control

anonymous@undisclosed.example.com (Anonymous) — Thu, 04 Jun 2026 06:39:56 +0000

←Radio Topics

Netradio Control

Python code for TCP/IP control of multiple radios

Server

This provides TCP/IP access to one or more radios, allowing control of Frequency, Mode, Pre-amp and Attenuator. It also gives remote access to S-meter readings.

There are separate rig-dependant command modules that then provide a standard interface for commands sent by a client, regardless of the particular radio connected.

There are modules for

Icom C-IV radios such as IC-R75, IC-718, IC-7200 etc.
AOR AR7030
Icom IC-M710 marine

Server

server.py

server.py

from aor import *
from icom import *
from conf import *
from m710 import *
import SocketServer
import time
 
try:
    import readline
except:
    pass
 
lock = threading.Lock()
 
radios = []
 
 
 
r1 = Icom(n1, a1, cal1)
radios.append(n1)
 
r2 = m710(n4)
radios.append(n4)
 
#r2 = Icom(n2, a2, cal2)
#radios.append(n2)
 
r3 = Ar7030(n3)
radios.append(n3)
 
print radios
#print r1.digi_off()
 
#print r2.remote_on()
 
def count_radios():
    count = len(radios)
    return count
 
 
def list_radios():
    radiolist = ""
    for n in range(0, len(radios)):
        r = radios[n]
        radiolist += (r + " ")
    return radiolist
 
 
def write_file(text):
    filename = 'commandlog.txt'
    f = open(filename, 'a+')  # a+ is "append to file, create it if it doesn't exist"
    timenow = time.strftime("%d/%m/%Y %H:%M:%S", time.gmtime(time.time()))
    log = " ".join((timenow, text))  # make an entry for the log by joining the timestamp with the text passed in
    f.write(log)
    f.close()
 
 
def write_con(text):
    filename = 'conlog.txt'
    f = open(filename, 'a+')  # a+ is "append to file, create it if it doesn't exist"
    timenow = time.strftime("%d/%m/%Y %H:%M:%S", time.gmtime(time.time()))
    log = " ".join((timenow, text))  # make an entry for the log by joining the timestamp with the text passed in
    f.write(log)
    f.close()
 
 
# The Server
class ThreadedRequestHandler(SocketServer.StreamRequestHandler):
    def handle(self):
        # we find the current thread for the client connection just set up, to
        # use in the log file
        cur_thread = threading.currentThread()
        # log the new connection details
        write_con("Connect from %s using %s \n" % ((self.client_address[0]), cur_thread.getName()))
        # print to the server's console the new connection IP address/port
        print self.client_address
        # loop to handle client requests....
        while True:
            # using StreamRequestHandler means our input from the client
            # is  "file-like" and can be read with "file-like" commands
            # we read a line at a time, using readline()
            cmd = self.rfile.readline().lower()
            # to keep things clean, we remove any characters that aren't
            # "printable" simple ASCII
            # these are between 32 and 127 in the ASCII table
            # we look at each character, and then make a new word by
            # .join()ing each accepted character with no space in between
            asccmd = "".join(x for x in cmd if ord(x) < 128 and ord(x) > 31)
            # we make a list called "words" holding the received words which
            # will be inspected by various functions
            words = asccmd.split()
            # If a client uses sock.close() itself, to disconnect, it appears that
            # we read a continuous stream of "" on the dead
            # socket, which puts CPU to 100%.
            #
            # The "While" loop is probably responsible, but I can't see another
            # way to keep the connection up for multiple commands.
            #
            # Further connection are accepted due to the Threaded nature of the server.
            # The CPU load is unacceptable though
            # HACK ?>>>>>
            # Looking for "" and then breaking
            # the connection from the server end (even though the client has
            # gone) cures this.
            if cmd == "":
                break
            else:
                pass
            # if the words list is empty, go back and get more input
            if not words:
                continue
            # we have input....
            # filter based on the first word - these are the
            # pre-set commands the server will accept
            # the client wants to know the currently available
            # radio names - held in the variable "rnames"
            elif words[0] == "getnames":
                self.wfile.write(rnames)
            # words[-1] (the last word in the list) will always be the
            # radio name. We give the variable "my_radio" this value, for
            # identifying which radio object to apply the method to
            elif words[0] == "count":
                count = count_radios()
                self.wfile.write(count)
            elif words[0] == "ident":
                ident_text = "GM4SLV Radio Server"
                radio_list = list_radios()
                self.wfile.write(ident_text + "\rAvailable : \n" + radio_list + "\r\n")
 
            elif words[0] == "getmode":
                my_radio = eval(words[-1])
                mode = my_radio.get_mode()
                self.wfile.write(mode)
            elif words[0] == "getfreq":
                my_radio = eval(words[-1])
                freq = words[1]
                freq = my_radio.get_freq()
                self.wfile.write(freq)
            elif words[0] == "setmode":
                my_radio = eval(words[-1])
                mode = words[1]
                newmode = my_radio.set_mode(mode)
                self.wfile.write(newmode)
            elif words[0] == "setfreq":
                my_radio = eval(words[-1])
                try:
                    freq = float(words[1])
                    newfreq = my_radio.set_freq(freq)
                    self.wfile.write(newfreq)
                except ValueError:
                    #freq = float(my_radio.get_freq())
                    self.wfile.write("Error in freq. %s No change\r\n" % words[1])
 
            elif words[0] == "getsmeter":
                my_radio = eval(words[-1])
                smeter = round(float(my_radio.get_smeter()), 1)
                self.wfile.write(smeter)
            elif words[0] == "gets":
                my_radio = eval(words[-1])
                s = my_radio.get_s()
                self.wfile.write(s)
            elif words[0] == "listradios":
                radios = list_radios()
                self.wfile.write(radios)
            elif words[0] == "getpreamp":
                my_radio = eval(words[-1])
                preamp = my_radio.get_pre()
                self.wfile.write(preamp)
            elif words[0] == "preampon":
                my_radio = eval(words[-1])
                preamp = my_radio.pre_on()
                self.wfile.write(preamp)
            elif words[0] == "preamp2on":
                my_radio = eval(words[-1])
                preamp = my_radio.pre_2_on()
                self.wfile.write(preamp)
            elif words[0] == "preampoff":
                my_radio = eval(words[-1])
                preamp = my_radio.pre_off()
                self.wfile.write(preamp)
            elif words[0] == "getatt":
                my_radio = eval(words[-1])
                att = my_radio.get_att()
                self.wfile.write(att)
            elif words[0] == "atton":
                my_radio = eval(words[-1])
                att = my_radio.att_on()
                self.wfile.write(att)
            elif words[0] == "attoff":
                my_radio = eval(words[-1])
                att = my_radio.att_off()
                self.wfile.write(att)
            elif words[0] == "tune":
                my_radio = eval(words[-1])
                tune = my_radio.tune()
                self.wfile.write(tune)
            elif words[0] == "getpwr":
                my_radio = eval(words[-1])
                pwr = my_radio.get_pwr()
                self.wfile.write(pwr)
            elif words[0] == "setpwr":
                my_radio = eval(words[-1])
                spwr = words[1]
                pwr = my_radio.set_pwr(spwr)
                self.wfile.write(pwr)
            elif words[0] == "quit":
                write_con("Got quit from {}\n".format(self.client_address[0]))  # log it
                self.wfile.write("Goodbye! \r\n")  # say Goodbye
                break
            else:  # nothing in words[0] matches a pre-set command....
                write_file("Received %s\n" % words)  # log it, it's unusual
                self.wfile.write("Command not recognized\r\n")  # inform the client
 
 
class ThreadedIcomServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
    pass
 
 
if __name__ == '__main__':
    # define the lock to be used on the serial port access
    lock = threading.Lock()
 
    # address ('' = all available interfaces) to listen on, and port number
    address = ('', 9999)
    server = ThreadedIcomServer(address, ThreadedRequestHandler)
    server.allow_reuse_address = True
 
    # define that the server will be threaded, and will serve "forever" ie. not quit after the client disconnects
    t = threading.Thread(target=server.serve_forever)
    # start the server thread
    t.start()
 
    write_con(
        "Server loop running in thread: %s\n" % "".join(t.getName()))

Configurtion Module

conf.py

Icom C-IV module

icom.py

icom.py

import serial
import threading
from conf import *
import time
#sport = "COM1"
sport = "/dev/ttyS0"
sbaud = 9600
 
lock = threading.Lock()
 
 
class Icom(object):
    def __init__(self, model, radio_address, cal):
        self.ser = serial.Serial(sport, sbaud, timeout=0.1)
        self.model = model
        self.radio_address = radio_address
        self.cal = cal
 
    def digi_off(self):
        sendStr = preamble + preamble + self.radio_address + controller + digi_off_cmd + eom
        result = self.tx_rx(sendStr)
        if result[4] == ack:
            return "Success"
        elif result[4] == nak:
            return "NAK received"
 
    def get_pre(self):
        sendStr = preamble + preamble + self.radio_address + controller + set_pre_cmd + eom
 
        result = self.tx_rx(sendStr)
        if not result:
            return "0"
        if result[6] == "\x00":
            return 0
        elif result[6] == "\x01":
            return 1
        elif result[6] == "\x02":
            return 2
 
    def get_pwr(self):
        sendStr = preamble + preamble + self.radio_address + controller + pwr_cmd + eom
        result = self.tx_rx(sendStr)
        if not result:
            return "0"
        p1 = ord(result[7]) / 16
        p2 = ord(result[7]) % 16
        p3 = ord(result[6]) / 16
        p4 = ord(result[6]) % 16
        pwr = float(100 * (10 * p3 + p4) + (10 * p1 + p2))
        return int(pwr*100/255)
 
    def set_pwr(self, pwr):
        #if pwr == "25":
        #    spwr = "\x00" + "\x63"
        #elif pwr == "50":
        #    spwr = "\x01" + "\x27"
        #elif pwr == "75":
        #    spwr = "\x01" + "\x91"
        #elif pwr == "100":
        #    spwr = "\x02" + "\x55"
        rigpwr = int(pwr) * 255 / 100
        print "rigpwr ", rigpwr
        pwr1 = rigpwr / 100
        pwr2 = rigpwr % 100
        spwr1 = (pwr1 / 10 * 16)
        spwr2 = (pwr1 % 10)
        spwr3 =  (pwr2 / 10 * 16)
        spwr4 =  (pwr2 % 10)
        spwr = chr(spwr1+spwr2) + chr(spwr3+spwr4)
        #print "spwr ", spwr
        sendStr = preamble + preamble + self.radio_address + controller + pwr_cmd + spwr + eom
        result = self.tx_rx(sendStr)
        if result[4] == ack:
            return self.get_pwr()
        elif result[4] == nak:
            return "NAK received"
 
    def pre_on(self):
        sendStr = preamble + preamble + self.radio_address + controller + set_pre_cmd + set_pre_on + eom
        result = self.tx_rx(sendStr)
        if result[4] == ack:
            return "Success"
        elif result[4] == nak:
            return "NAK received"
 
    def pre_2_on(self):
        sendStr = preamble + preamble + self.radio_address + controller + set_pre_cmd + set_pre_2_on + eom
        result = self.tx_rx(sendStr)
        if result[4] == ack:
            return "Success"
        elif result[4] == nak:
            return "NAK received"
 
 
    def pre_off(self):
        sendStr = preamble + preamble + self.radio_address + controller + set_pre_cmd + set_pre_off + eom
        result = self.tx_rx(sendStr)
        if result[4] == ack:
            return "Success"
        elif result[4] == nak:
            return "NAK received"
 
    def ptt_on(self):
        sendStr = preamble + preamble + self.radio_address + controller + ptt_on_cmd + eom
        result = self.tx_rx(sendStr)
        #print result[5]
        if not result[4] == ack:
            return "ptt on"
        elif result[4] == nak:
            return "Error"
 
    def ptt_off(self):
        sendStr = preamble + preamble + self.radio_address + controller + ptt_off_cmd + eom
        result = self.tx_rx(sendStr)
        #print result[5]
        if not result[4] == ack:
            return "ptt off"
        elif result[4] == nak:
            return "Error"
 
    def get_att(self):
        sendStr = preamble + preamble + self.radio_address + controller + set_att_cmd + eom
        result = self.tx_rx(sendStr)
        if not result:
            return "0"
        if result[5] == "\x00":
            return 0
        elif result[5] == "\x20":
            return 1
 
    def att_on(self):
        sendStr = preamble + preamble + self.radio_address + controller + set_att_cmd + set_att_on + eom
        result = self.tx_rx(sendStr)
        if result[4] == ack:
            return "Success"
        elif result[4] == nak:
            return "NAK received"
 
    def att_off(self):
        sendStr = preamble + preamble + self.radio_address + controller + set_att_cmd + set_att_off + eom
        result = self.tx_rx(sendStr)
        if result[4] == ack:
            return "Success"
        elif result[4] == nak:
            return "NAK received"
 
    def set_freq(self, freq):
        fdig = "%010d" % int(freq * 1000)
        bcd = ()
        for i in (8, 6, 4, 2, 0):
            bcd += self.freq_bcd(int(fdig[i]), int(fdig[i + 1]))
        set_freq_val = ""
        for byte in bcd:
            set_freq_val += chr(byte)
        sendStr = preamble + preamble + self.radio_address + controller + set_freq_cmd + set_freq_val + eom
        result = self.tx_rx(sendStr)
        if result[4] == ack:
            return "Set Freq success"
        elif result[4] == nak:
            return "NAK received / Freq not supported"
 
    def get_freq(self):
        sendStr = preamble + preamble + self.radio_address + controller + get_freq_cmd + eom
        result = self.tx_rx(sendStr)
        if not result:
            return "0"
        if len(result) > 0:
            f = 0
        for k in [18, 19, 16, 17, 14, 15, 12, 13, 10, 11]:
            f = 10 * f + self.nib(result, k)
        self.freq = (float(f) / 1000)
        return "%.3f" % self.freq
 
    def set_mode(self, mode):
        print "in set_mode() with ", mode
        if mode == "data":
            mode = "rtty"
 
        if mode == "lsb":
            set_mode_val = "\x00"
        elif mode == "usb":
            set_mode_val = "\x01"
        elif mode == "am":
            set_mode_val = "\x02"
        elif mode == "cw":
            set_mode_val = "\x03"
        elif mode == "rtty":
            set_mode_val = "\x04"
        elif mode == "fm":
            set_mode_val = "\x05"
        elif mode == "cw-r":
            set_mode_val = "\x07"
        elif mode == "rtty-r":
            set_mode_val = "\x08"
        elif mode == "s-am":
            set_mode_val = "\x11"
        else:
            return "Mode not recognized"
        sendStr = preamble + preamble + self.radio_address + controller + set_mode_cmd + set_mode_val + eom
        result = self.tx_rx(sendStr)
        if result[4] == ack:
            return "Set Mode Success"
        elif result[4] == nak:
            return "NAK received / Mode not supported"
 
    def get_mode(self):
        sendStr = preamble + preamble + self.radio_address + controller + get_mode_cmd + eom
        result = self.tx_rx(sendStr)
        if not result:
            return "0"
        mode = ""
        if result[5] == "\x00":
            mode = "lsb"
        elif result[5] == "\x01":
            mode = "usb"
        elif result[5] == "\x02":
            mode = "am"
        elif result[5] == "\x03":
            mode = "cw"
        elif result[5] == "\x04":
            mode = "rtty"
        elif result[5] == "\x05":
            mode = "fm"
        elif result[5] == "\x08":
            mode = "rtty-r"
        elif result[5] == "\x07":
            mode = "cw-r"
        elif result[5] == "\x11":
            mode = "s-am"
 
        if mode == "rtty":
            mode = "data"
 
        self.mode = mode
        return self.mode.upper()
 
    def get_s(self):
        sendStr = preamble + preamble + self.radio_address + controller + get_smeter_cmd + eom
        result = self.tx_rx(sendStr)
        if not result:
            return "0"
        sm1 = ord(result[7]) / 16
        sm2 = ord(result[7]) % 16
        sm3 = ord(result[6]) / 16
        sm4 = ord(result[6]) % 16
        s = float(100 * (10 * sm3 + sm4) + (10 * sm1 + sm2))
        return s
 
    def get_swr(self):
        sendStr = preamble + preamble + self.radio_address + controller + get_swr_cmd + eom
        result = self.tx_rx(sendStr)
        if not result:
            return "0"
        sm1 = ord(result[7]) / 16
        sm2 = ord(result[7]) % 16
        sm3 = ord(result[6]) / 16
        sm4 = ord(result[6]) % 16
        swr = float(100 * (10 * sm3 + sm4) + (10 * sm1 + sm2))
        return swr
 
    def get_smeter(self):
        s = float(self.get_s())
        cal = self.cal
        s1 = s - cal[0]
        s2 = s1 - cal[1]
        s3 = s2 - cal[2]
        s4 = s3 - cal[3]
        s5 = s4 - cal[4]
        s6 = s5 - cal[5]
        s7 = s6 - cal[6]
        if s1 <= 0:
            dbm = -123
            adj = s / cal[0] * 10
            return str(dbm + adj)
        elif s2 <= 0:
            dbm = -113
            adj = s1 / cal[1] * 10
            return str(dbm + adj)
        elif s3 <= 0:
            dbm = -103
            adj = s2 / cal[2] * 10
            return str(dbm + adj)
        elif s4 <= 0:
            dbm = -93
            adj = s3 / cal[3] * 10
            return str(dbm + adj)
        elif s5 <= 0:
            dbm = -83
            adj = s4 / cal[4] * 10
            return str(dbm + adj)
        elif s6 <= 0:
            dbm = -73
            adj = s5 / cal[5] * 10
            return str(dbm + adj)
        elif s7 <= 0:
            dbm = -63
            adj = s6 / cal[6] * 20
            return str(dbm + adj)
        else:
            dbm = -43
            adj = s7 / cal[7] * 20
            return str(dbm + adj)
 
    def get_name(self):
        return self.model
 
    def tune(self):
        print "tuning"
        curmode = self.get_mode().lower()
        #print "Current Mode ",curmode
 
        curpwr = self.get_pwr()
        if curpwr < 98:
            curpwr = curpwr + 1
 
        #print "Current Power ", curpwr
 
        #print "Current percent power ", curpwr
        self.set_mode("rtty")
        self.set_pwr(25)
        #print "Tuning power ", self.get_pwr()
        #print "PTT On"
        self.ptt_on()
        time.sleep(2)
        swr =  self.get_swr()
        #print "SWR :", swr
        time.sleep(1)
        self.ptt_off()
        #print "PTT Off"
        self.set_mode(curmode)
        #print "Mode reset ",self.get_mode()
        self.set_pwr(curpwr)
        print "Tuned : (ref pwr : %s)" % swr
        return "Tuned : (ref pwr : %s)" % swr
 
    def tx_rx(self, sendStr):
        lock.acquire()
        self.ser.write(sendStr)
        echo = self.ser.read(len(sendStr))
        if len(echo) != len(sendStr):
            return "0"
        byte = "0"
        result = ""
        count = 0
        while byte != eom:
            byte = self.ser.read()
            #print "%#02x" % ord(byte)
            result += byte
            count += 1
            if count > 10:
                break
        lock.release()
        #print ""
        return result
 
 
    def nib(self, s, i):
        k = ord(s[i / 2])
        if i % 2 == 0:
            k = k >> 4
        return k & 0xf
 
 
    def freq_bcd(self, d1, d2):
        return (16 * d1 + d2),

AOR AR7030 module

aor.py

aor.py

import serial
import threading
 
 
#sport = "/dev/ttyS0"
sport = "/dev/ttyUSB1"
sbaud = 1200
 
lock = threading.Lock()
fract = float(2 ** 24) / 44545
 
 
class Ar7030(object):
    def __init__(self, model):
        self.ser = serial.Serial(sport, sbaud, timeout=10)
        self.model = model
 
 
    def check_bit(self, byte, bit):
        mask = 1 << bit
        result = (ord(byte) & mask)
        if result:
            return 1
        else:
            return 0
 
    def set_bit(self, byte, bit):
        mask = 1 << bit
        result = ord(byte) | mask
        return result
 
    def clear_bit(self, byte, bit):
        mask = ~(1 << bit)
        result = (ord(byte) & mask)
        return result
 
    def get_ident(self):
        sendStr = '\x5f' + '\x40'
        ident = self.tx_rx(sendStr, False, 8)
        return ident
 
    def get_pre(self):
        sendStr = '\x50' + '\x32' + '\x48'
        byte = self.tx_rx(sendStr, False, 1)
        p = self.check_bit(byte, 4)
        if p:
            return 1
        else:
            return 0
        return
 
 
    def pre_on(self):
        #get current 8-bit rxcon byte :
        # bit0 = filter FS3
        # bit1 = filter FS2
        # bit2 = filter FS1
        # bit3 = filter FS4
        # bit4 = preamp enabled
        # bit5 = atten 0 = 20dB / 1 = 40dB
        # bit6 = input filter 0 = HF / 1 = LF
        # bit7 = attenuator enabled
 
        sendStr = '\x50' + '\x32' + '\x48'
 
        byte = self.tx_rx(sendStr, False, 1)
 
        # set bit 4 ON = preamp ON and get the new 8-bit rxcon byte
        pon = self.set_bit(byte, 4)
 
        # split new rxcon byte into two 4-bit nibbles, add 48/96 (\x30 and \x60)
        high = 48 + (pon >> 4)
        low = 96 + (pon & 15)
 
        sendStr = '\x81' + '\x50' + '\x32' + '\x48' + chr(high) + chr(low) + '\x29' + '\x80'
 
        self.tx_rx(sendStr, False, 0)
 
        return "Command sent"
 
 
    def pre_off(self):
        #get current 8-bit rxcon byte
        sendStr = '\x50' + '\x32' + '\x48'
        byte = self.tx_rx(sendStr, False, 1)
 
        # set bit 4 OFF = preamp OFF and get the new 8-bit rxcon byte
        pon = self.clear_bit(byte, 4)
 
 
        # split new rxcon byte into two 4-bit nibbles, add 48/96 (\x30 and \x60)
        high = 48 + (pon >> 4)
        low = 96 + (pon & 15)
 
        sendStr = '\x81' + '\x50' + '\x32' + '\x48' + chr(high) + chr(low) + '\x29' + '\x80'
 
        self.tx_rx(sendStr, False, 0)
        return "Command sent"
 
 
    def get_att(self):
        sendStr = '\x50' + '\x32' + '\x48'
 
        byte = self.tx_rx(sendStr, False, 1)
 
        a = self.check_bit(byte, 7)
 
        if a:
            return 1
        else:
            return 0
 
 
    def att_on(self):
        #get current 8-bit rxcon byte
        sendStr = '\x50' + '\x32' + '\x48'
        byte = self.tx_rx(sendStr, False, 1)
 
        # set bit 7 ON = ATT ON and get the new 8-bit rxcon byte
        pon = self.set_bit(byte, 7)
 
 
        # split new rxcon byte into two 4-bit nibbles, add 48/96 (\x30 and \x60)
        high = 48 + (pon >> 4)
        low = 96 + (pon & 15)
 
        sendStr = '\x81' + '\x50' + '\x32' + '\x48' + chr(high) + chr(low) + '\x29' + '\x80'
 
        self.tx_rx(sendStr, False, 0)
        return "Command sent"
 
 
    def att_off(self):
        #get current 8-bit rxcon byte
        sendStr = '\x50' + '\x32' + '\x48'
        byte = self.tx_rx(sendStr, False, 1)
 
        # set bit 7 OFF = att OFF and get the new 8-bit rxcon byte
        pon = self.clear_bit(byte, 7)
 
 
        # split new rxcon byte into two 4-bit nibbles, add 48/96 (\x30 and \x60)
        high = 48 + (pon >> 4)
        low = 96 + (pon & 15)
 
        sendStr = '\x81' + '\x50' + '\x32' + '\x48' + chr(high) + chr(low) + '\x29' + '\x80'
 
        self.tx_rx(sendStr, False, 0)
        return "Command sent"
 
 
    def set_freq(self, freq):
        fval = freq * fract
        #print fval
        b1 = 48 + int(fval / 1048576)
        fval = fval % 1048576
        b2 = 96 + int(fval / 65536)
        fval = fval % 65536
        b3 = 48 + int(fval / 4096)
        fval = fval % 4096
        b4 = 96 + int(fval / 256)
        fval = fval % 256
        b5 = 48 + int(fval / 16)
        b6 = 96 + int(fval % 16)
 
        f_tuple = ( b1, b2, b3, b4, b5, b6 )
 
        freqStr = ""
        for byte in f_tuple:
            freqStr += chr(byte)
 
        sendStr = '\x81' + '\x50' + '\x31' + '\x4a' + freqStr + '\x24' + '\x80'
 
        self.tx_rx(sendStr, False, 0)
        return "Freq Set"
 
    def get_freq(self):
 
        sendStr = '\x50' + '\x31' + '\x4a'
 
        freqStr = self.tx_rx(sendStr, False, 3)
 
        f_val = 0
        for k in freqStr:
            f_val = f_val * 256 + ord(k)
 
        return "%.3f" % round(float(f_val / fract),2 )
 
 
 
    def set_mode(self, mode):
 
        if mode == "lsb":
            set_mode_val = "\x66"
        elif mode == "usb":
            set_mode_val = "\x67"
        elif mode == "am":
            set_mode_val = "\x61"
        elif mode == "cw":
            set_mode_val = "\x65"
        elif mode == "data":
            set_mode_val = "\x64"
        elif mode == "fm":
            set_mode_val = "\x63"
        elif mode == "s-am":
            set_mode_val = "\x62"
        else:
            return "Mode not recognized"
 
        sendStr = '\x81' + '\x50' + '\x31' + '\x4d' + set_mode_val + '\x22' + '\x80'
 
        self.tx_rx(sendStr, False, 0)
 
        return "Mode sent"
 
    def get_mode(self):
 
        sendStr = "\x50" + "\x31" + "\x4d"
        m = self.tx_rx(sendStr, False, 1)
 
        mode = ""
        if m == "\x01":
            mode = "am"
        elif m == "\x02":
            mode = "s-am"
        elif m == "\x03":
            mode = "fm"
        elif m == "\x04":
            mode = "data"
        elif m == "\x05":
            mode = "cw"
        elif m == "\x06":
            mode = "lsb"
        elif m == "\x07":
            mode = "usb"
 
        return mode.upper()
 
 
    def get_s(self):
        sendStr = '\x2e'
        sraw = self.tx_rx(sendStr, True, 0)
 
        return ord(sraw)
 
    def get_cal(self):
 
        sendStr = '\x52' + '\x3f' + '\x44' + '\x11'
        #print "sending getcal"
        cbytes = self.tx_rx(sendStr, False, 8)
 
        cal = []
 
        for c in cbytes:
            cal.append(ord(c))
 
        return cal
 
    def get_smeter(self):
        s = float(self.get_s())
        cal = self.get_cal()
 
        s1 = s - cal[0]
        s2 = s1 - cal[1]
        s3 = s2 - cal[2]
        s4 = s3 - cal[3]
        s5 = s4 - cal[4]
        s6 = s5 - cal[5]
        s7 = s6 - cal[6]
 
        if s1 <= 0:
            dbm = -123
            adj = s / cal[0] * 10
            return str(dbm + adj)
 
        elif s2 <= 0:
            dbm = -113
            adj = s1 / cal[1] * 10
            return str(dbm + adj)
 
        elif s3 <= 0:
            dbm = -103
            adj = s2 / cal[2] * 10
            return str(dbm + adj)
 
        elif s4 <= 0:
            dbm = -93
            adj = s3 / cal[3] * 10
            return str(dbm + adj)
 
        elif s5 <= 0:
            dbm = -83
            adj = s4 / cal[4] * 10
            return str(dbm + adj)
 
        elif s6 <= 0:
            dbm = -73
            adj = s5 / cal[5] * 10
            return str(dbm + adj)
 
        elif s7 <= 0:
            dbm = -63
            adj = s6 / cal[6] * 20
            return str(dbm + adj)
 
        else:
            dbm = -43
            adj = s7 / cal[7] * 20
            return str(dbm + adj)
 
 
    def tx_rx(self, sendStr, reply, n):
        # apply thread lock
        lock.acquire()
        self.ser.write(sendStr)
 
        if reply:  # for reading S-meter
            result = ""
            while not result:
                result = self.ser.read(1)
            lock.release()
            return result
        else:
 
            result = ""
            byte = ""
            while n != 0:
                self.ser.write('\x71')
                #byte = ""
 
                while not byte:
                    byte = self.ser.read(1)
 
                result += byte
 
                byte = ""
                n -= 1
            lock.release()
            return result

Icom IC-M710 module

m710.py

m710.0y

'''
Python NMEA Radio Functions module for Icom IC-M710 Marine HF SSB Transceiver
 
    Copyright (C) 2015  John Pumford-Green
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program 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 General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
'''
 
# serial port for Icom IC-M710 Rig Control
 
import serial
import threading
import time
version = "v0.1"
 
sport = '/dev/ttyUSB0'
sbaud = 4800
 
#ser = serial.Serial(sport, 4800, timeout=1)
lock = threading.Lock()
 
# NMEA Codes
preamble = "$PICOA,"
controller = "90"
radio = "01" 
cr = "\x0d"
lf = "\x0a"
 
 
# Commands are sent as NMEA private sentences:
#
# $PICOA,controller_id,radio_id,command,<parameter>,*HH<CR><LF>
#
# where HH is the 2 digit ECC value below:
#
# The protocol document states that for messages FROM the controller TO the radio
# the ECC bytes are optional, and may be omitted. This appears to be false information, and
# the ECC bytes seem to be necessary.
#
# The ECC checksum, is a two-digit hex value found by XORing the hex values of the characters 
# between "$" and "*" (but not including the $ or *)
#
# The first part of the message is always:
# "PICOA,90,01," and this has an XOR value of (decimal) 112
# we then XOR this with each character's decimal ASCII value, in the required command
# and convert the result to a 2-digit hex value
#
 
class m710(object):
    def __init__(self, model):
        self.ser = serial.Serial(sport, sbaud, timeout=0.1)
        self.model = model
 
 
    def get_ecc(self,command):
        ecc = 112
        for c in command:
            ecc = ord(c) ^ ecc
        hecc = '{0:02x}'.format(int(ecc))
 
        return hecc
 
# we must force the radio into "Remote" mode before sending any other commands.    
    def remote_on(self):
        command = "REMOTE,ON"
        ecc = self.get_ecc(command)
        sendStr = preamble+controller+","+radio+","+command+"*"+ecc+cr+lf
        result = self.tx_rx(sendStr)
        if result:
            return
        else:
            return self.remote_on()
 
 
 
# we can leave the radio in "Remote" mode for as long as we want to control it remotely
# but we must close the "Remote" mode when finished. The previous radio settings (channel/power etc) are
# restored after Remote mode is closed.
    def remote_off(self):
        command = "REMOTE,OFF"
        ecc = self.get_ecc(command)
        sendStr = preamble+controller+","+radio+","+command+"*"+ecc+cr+lf
        result = self.tx_rx(sendStr) 
        if result:
            #ser.close()
            return
        else:
            return self.remote_off()
 
 
    def ptt_on():
        command = "TRX,TX"
        ecc = get_ecc(command)
        sendStr = preamble+controller+","+radio+","+command+"*"+ecc+cr+lf
        result = tx_rx(sendStr)
        if result:
            return
        else:
            return ptt_on()
 
    def ptt_off():
        command = "TRX,RX"
        ecc = get_ecc(command)
        sendStr = preamble+controller+","+radio+","+command+"*"+ecc+cr+lf
        result = tx_rx(sendStr)
        if result:
            return
        else:
            return ptt_off()
 
 
 
    def get_freq(self):
        fkhz = self.get_rxfreq()
        #fkhz = "%.3f" % (float(f) * 1000)
        return fkhz
 
    def set_freq(self,freq):
 
        self.set_rxfreq(freq)
        self.set_txfreq(freq)
        return "Set freq success"
 
    def get_rxfreq(self):
        command = "RXF"
        ecc = self.get_ecc(command)
        sendStr = preamble+controller+","+radio+","+command+"*"+ecc+cr+lf
        result = self.tx_rx(sendStr)
        if result:
            list = result.split(",")
            f = list[4].split("*")[0]
            fkhz = "%.3f" % (float(f) * 1000)
            return fkhz
        else:
            return self.get_rxfreq()
 
 
    def get_txfreq(self):
        command = "TXF"
        ecc = get_ecc(command)
        sendStr = preamble+controller+","+radio+","+command+"*"+ecc+cr+lf
        result = self.tx_rx(sendStr)
        if result:
            list = result.split(",")
            f = list[4].split("*")[0]
            fkhz = "%.3f" % (float(f) * 1000)
            return fkhz
        else:
            return self.get_txfreq()
 
 
    def get_mode(self):
        command = "MODE"
        ecc = self.get_ecc(command)
        sendStr = preamble+controller+","+radio+","+command+"*"+ecc+cr+lf
        result = self.tx_rx(sendStr)
        if result:
            list = result.split(",")
            mode = list[4].split("*")[0]
            if mode == "J2B":
                mode = "DATA"
            return mode
        else:
            return self.get_mode()
 
 
 
    def set_mode(self,mode):
        mode = mode.upper()
        if mode == "DATA":
            mode = "J2B"
 
        command = "MODE,"+mode
        ecc = self.get_ecc(command)
 
        sendStr = preamble +controller+","+radio+"," + command + "*"+ecc+cr+lf
        #print "in set_mode with ", sendStr
        result = self.tx_rx(sendStr)
        if result:
            return result
        else:
            return self.set_mode(mode)
 
 
    def set_rxfreq(self,freq):
 
        fmhz = float(freq) / 1000
        f = str(fmhz)
 
        command = "RXF,"+f
        ecc = self.get_ecc(command)
        sendStr = preamble +controller+","+radio+"," + command + "*"+ecc+cr+lf
        result = self.tx_rx(sendStr)
        if result:
            return result
        else:
            return self.set_rxfreq(freq)
 
 
    def set_txfreq(self,freq):
 
        fmhz = float(freq) / 1000
        f = str(fmhz)
 
        command = "TXF,"+f
        ecc = self.get_ecc(command)
        sendStr = preamble +controller+","+radio+"," + command + "*"+ecc+cr+lf
        result = self.tx_rx(sendStr)
        if result:
            return result
        else:
            return self.set_txfreq(freq)
 
    def get_txpower():
        command = "TXP"
        ecc = get_ecc(command)
        sendStr = preamble +controller+","+radio+"," + command + "*"+ecc+cr+lf
        result = tx_rx(sendStr)
        if result:
            list = result.split(",")
            power = list[4].split("*")[0]
            return power
        else:
            return get_txpower()
 
    def set_txpower(p):
        command = "TXP,"+p
        ecc = get_ecc(command)
        sendStr = preamble +controller+","+radio+"," + command + "*"+ecc+cr+lf
        result = tx_rx(sendStr)
        if result:
            return result
        else:
            return set_txpower(p)
 
    def get_smeter(self):
        command = "SIGM"
        ecc = self.get_ecc(command)
        sendStr = preamble+controller+","+radio+","+command+"*"+ecc+cr+lf
        result = self.tx_rx(sendStr)
        if result:
            list = result.split(",")
            smeter = (float(list[4].split("*")[0]) * 20) - 120 
            return smeter
        else:
            return self.get_smeter()
 
    def speaker_on():
        command = "SP,ON"
        ecc = get_ecc(command)
        sendStr = preamble +controller+","+radio+"," + command + "*"+ecc+cr+lf
        result = tx_rx(sendStr)
        if result:
            return result
        else:
            return speaker_on()
 
 
    def speaker_off():
        command = "SP,OFF"
        ecc = get_ecc(command)
        sendStr = preamble +controller+","+radio+"," + command + "*"+ecc+cr+lf
        result = tx_rx(sendStr)
        if result:
            return result
        else:
            return speaker_off()
 
    def sql_on():
        command = "SQLC,ON"
        ecc = get_ecc(command)
        sendStr = preamble +controller+","+radio+"," + command + "*"+ecc+cr+lf
        result = tx_rx(sendStr)
        if result:
            return result
        else:
            return sql_on()
 
    def sql_off():
        command = "SQLC,OFF"
        ecc = get_ecc(command)
        sendStr = preamble +controller+","+radio+"," + command + "*"+ecc+cr+lf
        result = tx_rx(sendStr)
        if result:
            return result
        else:
            return sql_off()
 
    def nb_on():
        command = "NB,ON"
        ecc = get_ecc(command)
        sendStr = preamble +controller+","+radio+"," + command + "*"+ecc+cr+lf
        result = tx_rx(sendStr)
        if result:
            return result
        else:
            return nb_on()
 
    def nb_off():
        command = "NB,OFF"
        ecc = get_ecc(command)
        sendStr = preamble +controller+","+radio+"," + command + "*"+ecc+cr+lf
        result = tx_rx(sendStr)
        if result:
            return result
        else:
            return nb_off()
 
    def dim_on():
        command = "DIM,ON"
        ecc = get_ecc(command)
        sendStr = preamble +controller+","+radio+"," + command + "*"+ecc+cr+lf
        result = tx_rx(sendStr)
        if result:
            return result
        else:
            return dim_on()
 
    def dim_off():
        command = "DIM,OFF"
        ecc = get_ecc(command)
        sendStr = preamble +controller+","+radio+"," + command + "*"+ecc+cr+lf
        result = tx_rx(sendStr)
        if result:
            return result
        else:
            return dim_off()
 
    def agc_on():
        command = "AGC,ON"
        ecc = get_ecc(command)
        sendStr = preamble +controller+","+radio+"," + command + "*"+ecc+cr+lf
        result = tx_rx(sendStr)
        if result:
            return result
        else:
            return agc_on()
 
    def agc_off():
        command = "AGC,OFF"
        ecc = get_ecc(command)
        sendStr = preamble +controller+","+radio+"," + command + "*"+ecc+cr+lf
        result = tx_rx(sendStr)
        if result:
            return result
        else:
            return agc_off()
 
    def get_vol():
        command = "AFG"
        ecc = get_ecc(command)
        sendStr = preamble+controller+","+radio+","+command+"*"+ecc+cr+lf
        result = tx_rx(sendStr)
        if result:
            list = result.split(",")
            vol = list[4].split("*")[0]
            return vol
        else:
            return get_vol()
 
 
 
    def set_vol(v):
        command = "AFG,"+v
        ecc = get_ecc(command)
        sendStr = preamble +controller+","+radio+"," + command + "*"+ecc+cr+lf
        result = tx_rx(sendStr)
        if result:
            return result
        else:
            return set_vol(v)
 
    def get_rfg():
        command = "RFG"
        ecc = get_ecc(command)
        sendStr = preamble+controller+","+radio+","+command+"*"+ecc+cr+lf
        result = tx_rx(sendStr)
        if result:
            list = result.split(",")
            rf = list[4].split("*")[0]
            return rf
        else:
            return get_rfg()
 
    def get_att(self):
        return
    def att_on(self):
        return
    def att_off(self):
        return
 
    def pre_on(self):
        return
    def pre_off(self):
        return
 
    def get_pre(self):
        return
 
    def set_rfg(v):
        command = "RFG,"+v
        ecc = get_ecc(command)
        sendStr = preamble +controller+","+radio+"," + command + "*"+ecc+cr+lf
        result = tx_rx(sendStr)
        if result:
            return result
        else:
            return set_rfg(v)
 
    # The message FROM the radio may be corrupted so we do a check on the received ECC versus our calculated cECC
    # from the received characters - which are everything AFTER the "$" and BEFORE the "*"
    #
    # starting the ECC calculation at message[1] ignores the "$" and we iterate through the message XORing each 
    # character's ASCII (decimal) value until we have the final cECC which is converted by formatting it
    # into a two-digit hex value. This is then compared to the received (rECC) value from the radio's message. 
    # If they match the message is acceptable and check_ecc() returns True to tx_rx(), 
    # otherwise check_ecc() function returns "False" to tx_rx()
    # the True/False value is tested in tx_rx(). 
    # If True then tx_rx() returns the incoming string to the calling function
    # otherwise it returns "False". 
    # The calling function then checkS the boolean state of the returned value. 
    # If True (ie it has the radio's message and the ECC was good) the message 
    # is sent back to the client. 
    # If False the function calls itself again, and attempts to get an error-free reply from the radio, via tx_rx()
 
    def check_ecc(self,message, recc):
        i = 1
        cecc = 0
 
        while i < len(message):
            cecc = ord(message[i]) ^ cecc
            i += 1  
 
        cecc = '{0:02x}'.format(int(cecc))  
 
        if cecc == recc:   
            return True
        else: 
            return False
 
    def tx_rx(self,sendStr):
        #print "in tx_rx, sendStr =  " , sendStr
        lock.acquire()
 
        self.ser.write(sendStr)
        time.sleep(0.1)
        result = self.ser.readline()
 
        #print result
        reply = result.split("*")
        ecc = reply[1][0:2].lower()
        message = reply[0]
        lock.release()
 
        if self.check_ecc(message, ecc):
            return result
        else:
            return False
 
 
 
 
 
#

Text-mode client

client.py

client.py

__author__ = 'gm4slv'
# client to work with server_oo.py
# 
 
# # v0.1
 
import socket
 
try:
    import readline
except ImportError:
    pass
 
import threading
import time
 
 
HOST, PORT = "localhost", 9999
 
smlog = "pymon.txt"
log_active = []
 
 
def make_con():
    global sock
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.connect((HOST, PORT))
 
 
def get_rnum():
    global num
    global radios
 
    names = connect("listradios")
 
    radios = names.split()
    num = len(radios)
    return num
 
 
def get_rname(i):
    r = radios[i]
    return r
 
 
def list_radios():
    num = get_rnum()
    global radio
    print "\r\nThere are currently %d radios connected." % num
    for i in range(0, num):
        r = get_rname(i)
        print "Radio %d is %s" % (i + 1, r)
 
 
def get_lradio():
    num = get_rnum()
 
    lradio = raw_input("Select radio to log: ").strip()
 
    if not lradio:
        print "Please select a radio"
        return False
    elif int(lradio) > num:
        print "Selected radio not recognized"
        return False
 
    else:
 
        return lradio
 
 
def set_radio():
    num = get_rnum()
    # global radio
    global radio_num
    global rname
    print "There are currently %d radios connected." % num
    for i in range(0, num):
        r = get_rname(i)
        print "Radio %d is %s" % (i + 1, r)
 
    radio = raw_input("Choose a radio number from the list : ").strip()
    try:
        if not radio:
            print "Please select a radio"
            return False, False
 
        elif int(radio) > num:
            print "Selected radio not recognized"
            return False, False
    except ValueError:
        print "Please enter a number"
        return False, False
 
    else:
        radio_num = "".join(("r", radio))
        rname = get_rname(int(radio) - 1)
        return radio_num, rname
 
 
def prompt():
    print ""
    print "The available commands are:"
    print "lr   : List Radios"
    print "sr   : Select the Radio to control"
    print "gr   : Get currently selected Radio name"
    print "gm   : Get Mode"
    print "sm   : Set Mode"
    print "gf   : Get Freq"
    print "sf   : Set Freq"
    print "gs   : Get S-meter"
    print "gp   : Get Pre-amp"
    print "pon  : Set Pre-amp On"
    print "p2on : Set Pre-amp 2 On"
    print "poff : Set Pre-amp Off"
    print "gatt : Get Attn"
    print "aton : Set Attn On"
    print "atoff: Set Attn Off"
    print "ga   : Get All (status of all radios)"
    print "sync : Sync freq/mode on two radios"
    print "log  : Setup background logging to file"
    print "h    : Help (show this command list)"
    print "q    : quit"
    print ""
 
 
def start():
    global radio_num
    global rname
    global sock
    pfreq = connect("getfreq" + " " + radio_num)
    pmode = connect("getmode" + " " + radio_num)
 
    data = raw_input(rname + " (" + pfreq + " " + pmode + ") " + " > ").lower().strip()
    if len(data.split()) > 1:
        if (data.split())[0] == "sf":
            sfreq = (data.split())[1]
            freq = connect("setfreq" + " " + sfreq + " " + radio_num)
            print "%s replied: %s" % (rname, freq)
            start()
        elif (data.split())[0] == "sm":
            smode = (data.split())[1]
            mode = connect("setmode" + " " + smode + " " + radio_num)
            print "%s replied: %s" % (rname, mode)
            start()
        else:
 
            print "only one command at a time please"
            start()
    elif data == "u":
        oldf = connect("getfreq" + " " + radio_num)
        newf = str(float(oldf) + 1)
        freq = connect("setfreq" + " " + newf + " " + radio_num)
        print "%s replied: %s" % (rname, freq)
        start()
 
    elif data == "d":
        oldf = connect("getfreq" + " " + radio_num)
        newf = str(float(oldf) - 1)
        freq = connect("setfreq" + " " + newf + " " + radio_num)
        print "%s replied: %s" % (rname, freq)
        start()
 
    elif data == "lr":
        list_radios()
        start()
    elif data == "sr":
 
        radio_num, rname = set_radio()
 
        while not radio_num:
            radio_num, rname = set_radio()
 
        start()
 
    elif data == "gr":
        print "Radio selected is %s" % rname
        start()
 
    elif data == "gm":
        mode = connect("getmode" + " " + radio_num)
        print "%s replied: %s" % (rname, mode)
        start()
 
    elif data == "sm":
        smode = raw_input("Enter mode: ")
        mode = connect("setmode" + " " + smode + " " + radio_num)
        print "%s replied: %s" % (rname, mode)
        start()
 
    elif data == "gf":
        freq = connect("getfreq" + " " + radio_num)
        print "%s replied: %s kHz" % (rname, freq)
        start()
 
    elif data == "sf":
        sfreq = raw_input("Enter freq (kHz): ")
        freq = connect("setfreq" + " " + sfreq + " " + radio_num)
        print "%s replied: %s" % (rname, freq)
        start()
 
    elif data == "gs":
        smeter = connect("getsmeter" + " " + radio_num)
        print "%s replied: %sdBm" % (rname, smeter)
        start()
 
    elif data == "gp":
        preamp = connect("getpreamp" + " " + radio_num)
        print "%s replied: %s" % (rname, preamp)
        start()
 
    elif data == "pon":
        preamp = connect("preampon" + " " + radio_num)
        print "%s replied: %s" % (rname, preamp)
        start()
 
    elif data == "p2on":
        preamp = connect("preamp2on" + " " + radio_num)
        print "%s replied: %s" % (rname, preamp)
        start()
 
    elif data == "poff":
        preamp = connect("preampoff" + " " + radio_num)
        print "%s replied: %s" % (rname, preamp)
        start()
 
    elif data == "gatt":
        preamp = connect("getatt" + " " + radio_num)
        print "%s replied: %s" % (rname, preamp)
        start()
 
    elif data == "aton":
        att = connect("atton" + " " + radio_num)
        print "%s replied: %s" % (rname, att)
        start()
 
    elif data == "atoff":
        att = connect("attoff" + " " + radio_num)
        print "%s replied: %s" % (rname, att)
        start()
 
    elif data == "ga":
        get_all()
        start()
 
 
    elif data == "log":
        fname = raw_input("Enter a filename (or \"Return\" for default) :")
        if fname == "":
            fname = smlog
        # check file is valid
        try:
            f = open(fname, 'a+')
            f.close()
        except IOError:
            print "File/path not valid"
            start()
 
        list_radios()
 
        lradio = get_lradio()
 
        while not lradio:
            lradio = get_lradio()
 
        rname = get_rname(int(lradio) - 1)
        if lradio in log_active:
            print "Logging already active on " + rname
        else:
            tlog = int(raw_input("Enter a polling interval (seconds) :"))
            p = threading.Thread(target=log, args=(lradio, tlog, fname))
            p.setDaemon(True)
            p.start()
            log_active.append(lradio)
        start()
 
    elif data == "sync":
        sync_result = sync()
        print sync_result
        start()
 
 
    elif data == "h" or data == "help":
        prompt()
        start()
 
 
    elif data == "q" or data == "quit":
        rx = connect("quit")
        print "Server says: %s " % rx
 
    else:
        #prompt()
        start()
 
 
def get_all():
    num = get_rnum()
    global radio
    print "There are currently %d radios connected." % num
    print "=" * 33
    for i in range(0, num):
        r = get_rname(i)
        n = "".join(("r", str(i + 1)))
        freq = connect("getfreq" + " " + n)
        mode = connect("getmode" + " " + str(n))
        smeter = connect("getsmeter" + " " + str(n))
        preamp = connect("getpreamp" + " " + str(n))
        att = connect("getatt" + " " + str(n))
 
        print "Status of Radio %d (%s) \r\n" % (i + 1, r)
        print "Frequency : %s kHz" % freq
        print "Mode: %s" % mode
        print "S-Meter: %sdBm" % smeter
        print "Preamp = %s" % preamp
        print "Attenuator = %s " % att
        print "=" * 33
 
    print ""
 
 
def log(p, t, f):
    print "\n\n"
    tlog = t
    sradio = get_rname(int(p) - 1)
 
    sr = "".join(("r", str(p)))
    while True:
        try:
            frequency = connect("getfreq" + " " + sr + "\n")
            smeter = connect("getsmeter" + " " + sr + "\n")
            mode = connect("getmode" + " " + sr + "\n")
            write_file(f, sradio, mode, frequency, smeter)
            time.sleep(tlog)
        finally:
            pass
 
 
def get_mradio():
    num = get_rnum()
 
    mradio = raw_input("Choose Master radio number from the list: ").strip()
 
    if not mradio:
        print "Please select a radio"
        return False
    elif int(mradio) > num:
        print "Selected radio not recognized"
        return False
 
    else:
 
        return mradio
 
 
def get_sradio():
    num = get_rnum()
    sradio = raw_input("Choose Slave radio number from the list: ").strip()
 
    if not sradio:
        print "Please select a radio"
        return False
    elif int(sradio) > num:
        print "Selected radio not recognized"
        return False
 
    else:
 
        return sradio
 
 
def sync():
    num = get_rnum()
    print ""
    print "Set SLAVE to the same Frequency and Mode as MASTER.\r\n"
    print "Currently connected radios are:"
    for i in range(0, num):
        r = get_rname(i)
        print "%d is %s" % (i + 1, r)
 
    mradio = get_mradio()
    while not mradio:
        mradio = get_mradio()
 
    sradio = get_sradio()
    while not sradio:
        sradio = get_sradio()
    sr = "".join(("r", sradio))
    mr = "".join(("r", mradio))
    mfreq = connect("getfreq" + " " + mr)
    mmode = connect("getmode" + " " + mr)
 
    sfreq = connect("setfreq" + " " + mfreq + " " + sr)
    smode = connect("setmode" + " " + mmode + " " + sr)
 
    return (sfreq + "\r\n" + smode + "\r\n")
 
 
# Try to send and receive in one-go, to prevent the logging thread and the main prog
# getting the wrong receive data
 
def connect(data):
    try:
        lock.acquire()
        global sock
        sock.sendall(data + "\n")
        received = sock.recv(2048)
    finally:
        lock.release()
 
    return received
 
 
def write_file(fname, rname, mode, freq, smeter):
    filename = fname
    f = open(filename, 'a+')
    timenow = time.strftime("%d/%m/%Y %H:%M:%S", time.gmtime(time.time()))
    log = " ".join((timenow, rname, mode, freq, smeter, "\r\n"))
    f.write(log)
    f.close()
 
 
make_con()
 
lock = threading.Lock()
get_all()
print "Please choose a radio\r\n"
radio_num, rname = set_radio()
while not radio_num:
    radio_num, rname = set_radio()
 
prompt()
start()

Example session

There are currently 3 radios connected.
=================================
Status of Radio 1 (IC-R75) 
 
Frequency : 2187.500 kHz
Mode: DATA
S-Meter: -114.2dBm
Preamp = 0
Attenuator = 0 
=================================
Status of Radio 2 (IC-M710) 
 
Frequency : 16804.500 kHz
Mode: DATA
S-Meter: -120.0dBm
Preamp = None
Attenuator = None 
=================================
Status of Radio 3 (AR7030) 
 
Frequency : 2182.000 kHz
Mode: USB
S-Meter: -110.3dBm
Preamp = 0
Attenuator = 0 
=================================
 
Please choose a radio
 
There are currently 3 radios connected.
Radio 1 is IC-R75
Radio 2 is IC-M710
Radio 3 is AR7030
Choose a radio number from the list : 3
 
The available commands are:
lr   : List Radios
sr   : Select the Radio to control
gr   : Get currently selected Radio name
gm   : Get Mode
sm   : Set Mode
gf   : Get Freq
sf   : Set Freq
gs   : Get S-meter
gp   : Get Pre-amp
pon  : Set Pre-amp On
p2on : Set Pre-amp 2 On
poff : Set Pre-amp Off
gatt : Get Attn
aton : Set Attn On
atoff: Set Attn Off
ga   : Get All (status of all radios)
sync : Sync freq/mode on two radios
log  : Setup background logging to file
h    : Help (show this command list)
q    : quit
 
AR7030 (2182.000 USB)  > sf 5680
AR7030 replied: Freq Set
AR7030 (5680.000 USB)  >

GUI Client

No S-meter version

gui_nosmeter.py

gui_nosmeter.py

# # new class-based gui
 
from Tkinter import *
import socket
import threading
import time
 
 
 
class Network(object):
    def __init__(self):
        self.sock = self.make_con()
 
    def make_con(self):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.connect(("192.168.21.107", 9999))
        return self.sock
 
    def connect(self, data):
        try:
            lock.acquire()
            self.sock.sendall(data + "\n")
            self.received = self.sock.recv(2048)
        finally:
            lock.release()
            return self.received
 
class Dash(object):
    def __init__(self, master):
        self.master = master
 
        self.s = (n1.sock.getsockname())
        self.p = (n1.sock.getpeername())
 
 
 
        dash_frame = Toplevel(master, borderwidth = 2, relief = GROOVE, bg = 'black')
        dash_frame.title("Server")
        dash_frame.protocol("WM_DELETE_WINDOW", self.handler)
        dash_frame.resizable(0, 0)
        dash_frame.geometry("300x150+10-10")
        dash_frame.grid()
 
        #self.utc_time = StringVar()
        #Label(dash_frame, textvariable = self.utc_time, fg = 'green', bg = 'black').grid(row = 0, column = 0, sticky = W)
 
        Label(dash_frame, text = self.s, bg = 'black', fg = 'white').grid(row = 1, column = 0, sticky = W)
 
        Label(dash_frame, text = " < --- > ", bg = 'black', fg = 'white').grid(row = 1, column = 1)
 
        Label(dash_frame, text = self.p, bg = 'black', fg = 'white').grid(row = 1, column = 2, sticky = E)
 
        self.server_msg_l = StringVar()
        Label(dash_frame, textvariable = self.server_msg_l, fg = 'yellow', bg = 'black').grid(row = 2, column = 0, columnspan = 3, sticky = W)
 
        q_button = Button(dash_frame, text = "Quit", command = lambda: close())
        q_button.grid(row = 3, column = 0, sticky = W)
 
    def handler(self):
        pass
 
    def up_dash(self):
        self.server_msg = n1.connect("ident")
        self.server_msg_l.set(self.server_msg)
        #self.utc_time.set(time.strftime("%d/%m/%Y %H:%M", time.gmtime(time.time())))
        return
 
class nRadio(object):
    def __init__(self, master, radio):
        self.master = master
 
        self.radio = radio
        self.num = "".join(("r", self.radio))
 
 
        radio_frame = Frame(master, borderwidth=2, relief=GROOVE)
 
        radio_frame.grid()
        self.smeter_list = []
 
        Label(radio_frame, text="Name", width=10).grid(row=0, column=0)
        Label(radio_frame, text="Freq/kHz", width=10).grid(row=0, column=1)
        Label(radio_frame, text="Mode", width=10).grid(row=0, column=2)
        #Label(radio_frame, text="Signal/dBm", width=10).grid(row=0, column=3)
        #Label(radio_frame, text="Max/dBm", width=10, fg='red').grid(row=0, column=4)
        #Label(radio_frame, text="Ave/dBm", width=10, fg='green').grid(row=0, column=5)
        #Label(radio_frame, text="Min/dBm", width=10, fg='blue').grid(row=0, column=6)
 
        self.name_l = StringVar()
        self.l_name = Label(radio_frame, textvariable=self.name_l, width=10)
        self.l_name.grid(row=1, column=0, sticky=W)
 
        self.freq_l = StringVar()
        self.l_freq = Label(radio_frame, fg='red', textvariable=self.freq_l, width=10)
        self.l_freq.grid(row=1, column=1, sticky=E)
 
        self.mode_l = StringVar()
        self.l_mode = Label(radio_frame, textvariable=self.mode_l, width=10)
        self.l_mode.grid(row=1, column=2, sticky=E)
        '''
        self.e_mode = Entry(radio_frame, width=10, bg = 'white', fg = 'black', insertbackground = 'blue')
        self.e_mode.grid(row=2, column=2)
        self.e_mode.bind('<Return>', (lambda event: self.set_mode(self.num)))
        '''
        #self.e_mode = StringVar()
        self.b_mode_usb = Button(radio_frame, text = "USB", width = 4, command = lambda: self.set_mode("usb", self.num))
        self.b_mode_usb.grid(row = 3, column = 0)
 
        self.b_mode_lsb = Button(radio_frame, text = "LSB", width = 4, command = lambda: self.set_mode("lsb", self.num))
        self.b_mode_lsb.grid(row = 3, column = 1)
 
        self.b_mode_cw = Button(radio_frame, text = "CW", width = 4, command = lambda: self.set_mode("cw", self.num))
        self.b_mode_cw.grid(row = 4, column = 0)
 
        self.b_mode_am = Button(radio_frame, text = "AM", width = 4, command = lambda: self.set_mode("am", self.num))
        self.b_mode_am.grid(row = 4, column = 1)
 
        self.b_mode_data = Button(radio_frame, text = "Data", width = 4, command = lambda: self.set_mode("data", self.num))
        self.b_mode_data.grid(row = 3, column = 2)
 
        self.b_qsy_up = Button(radio_frame, text = "+1kHz", width = 6, command = lambda: self.qsy_up( self.num))
        self.b_qsy_up.grid(row = 3, column = 3)
 
        self.b_qsy_down = Button(radio_frame, text = "-1kHz", width = 6, command = lambda: self.qsy_down( self.num))
        self.b_qsy_down.grid(row = 4, column = 3)
 
        self.b_update = Button(radio_frame, text = "Get", width = 6, command = lambda:self.get_all())
        self.b_update.grid(row = 0, column = 3)
 
 
        self.smeter_l = StringVar()
        self.l_smeter = Label(radio_frame, textvariable=self.smeter_l, width=10)
        #self.l_smeter.grid(row=1, column=3, sticky=E)
 
        self.max_var = StringVar()
        self.l_max = Label(radio_frame, textvariable=self.max_var, width=10)
        #self.l_max.grid(row=1, column=4)
 
        self.ave_var = StringVar()
        self.l_average = Label(radio_frame, textvariable=self.ave_var, width=10)
        #self.l_average.grid(row=1, column=5)
 
        self.min_var = StringVar()
        self.l_min = Label(radio_frame, textvariable=self.min_var, width=10)
        #self.l_min.grid(row=1, column=6)
 
        self.e_freq = Entry(radio_frame, width=10, bg = 'white', fg = 'black', insertbackground = 'blue')
        self.e_freq.grid(row=2, column=1)
        self.e_freq.focus()
        self.e_freq.bind('<Return>', (lambda event: self.set_freq(self.num)))
 
 
 
        self.pre = IntVar()
        self.cb_pre = Checkbutton(radio_frame, variable=self.pre, command=lambda: self.preamp_onoff(self.num))
        self.cb_pre.grid(row=5, column=3, sticky=E)
 
        self.l_pre = Label(radio_frame, width=10, text="Preamp")
        self.l_pre.grid(row=5, column=2, sticky=W)
 
        self.att = IntVar()
        self.cb_att = Checkbutton(radio_frame, variable=self.att, command=lambda: self.att_onoff(self.num))
        self.cb_att.grid(row=6, column=3, sticky=E)
 
        self.l_att = Label(radio_frame, width=10, text="Att")
        self.l_att.grid(row=6, column=2, sticky=W)
 
        self.set_log = IntVar()
        self.cb_log = Checkbutton(radio_frame, variable = self.set_log)
        #self.cb_log.grid(row = 6, column = 1, sticky = W)
 
        self.l_log = Label(radio_frame, width = 10, text = "Log to file...")
        #self.l_log.grid(row = 6, column = 0, sticky = E)
 
        self.c1 = Canvas(radio_frame, width=260, height=100, bg='black')
        #self.c1.grid(row=2, column=3, columnspan=4, rowspan=3)
 
        name = self.get_name(radio)
 
 
    def get_all(self):
 
        self.get_freq(self.num)
        self.get_mode(self.num)
        #self.get_smeter(self.num)
        self.get_preamp(self.num)
        self.get_atten(self.num)
        #self.graph_points()       
        #self.avg()
        #self.max()
        #self.min()
 
        if self.set_log.get() == 1:
            if int(time.time()) % 10.0 == 0:
                self.write_file()
        return
 
    def get_freq(self, radio):
 
        self.freq = n1.connect("getfreq" + " " + radio)
        self.freq_l.set(self.freq)
        return
 
    def set_freq(self, radio):
        self.freq = str(self.e_freq.get())
        self.newfreq = n1.connect("setfreq" + " " + self.freq + " " + radio)
        self.e_freq.delete(0, END)
        self.get_all()
        return
 
    def qsy_up(self,radio):
 
        oldf = n1.connect("getfreq" + " " + radio)
        newf = str(float(oldf) + 1)
        freq = n1.connect("setfreq" + " " + newf + " " + radio)
        self.get_all()
        return
 
    def qsy_down(self,radio):
        oldf = n1.connect("getfreq" + " " + radio)
        newf = str(float(oldf) - 1)
        freq = n1.connect("setfreq" + " " + newf + " " + radio)
        self.get_all()
        return
 
    def get_mode(self, radio):
        self.mode = n1.connect("getmode" + " " + radio)
        self.mode_l.set(self.mode)
        return
 
    def set_mode(self, mode, radio):
        #self.mode = str(self.e_mode.get())
        self.newmode = n1.connect("setmode" + " " + mode + " " + radio)
        #self.e_mode.delete(0, END)
        self.get_all()
        return
 
    def get_smeter(self, radio):
        self.smeter = n1.connect("getsmeter" + " " + radio)
        self.smeter_l.set(self.smeter)
        self.smeter_list.append(float(self.smeter))
        if len(self.smeter_list) > 120:
            self.smeter_list.pop(0)
        return
 
    def avg(self):
        s = self.smeter_list
        total = 0
        for i in s:
            total += i
        self.av = round((total / len(s)), 1)
        self.ave_var.set(str(self.av))
        self.c1.create_line(0, 100 - (self.av + 123 + 5), 310, 100 - (self.av + 123 + 5), fill="green")
        return self.av
 
    def min(self):
        s = self.smeter_list
        self.mn = s[0]
        for i in s:
            if i < self.mn:
                self.mn = i
        self.min_var.set(str(self.mn))
        self.c1.create_line(0, 100 - (self.mn + 123 + 5), 310, 100 - (self.mn + 123 + 5), fill="blue")
        return self.mn
 
    def max(self):
        s = self.smeter_list
        self.mx = s[0]
        for i in s:
            if i > self.mx:
                self.mx = i
        self.max_var.set(str(self.mx))
        self.c1.create_line(0, 100 - (self.mx + 123 + 5), 310, 100 - (self.mx + 123 + 5), fill="red")
        return self.mx
 
    def get_preamp(self, radio):
        self.preamp = n1.connect("getpreamp" + " " + radio)
        if self.preamp == "1":
            self.cb_pre.select()
        elif self.preamp == "0":
            self.cb_pre.deselect()
        return
 
    def preamp_onoff(self, radio):
        self.prestate = self.pre.get()
        if self.prestate:
            n1.connect("preampon" + " " + radio)
        else:
            n1.connect("preampoff" + " " + radio)
        self.get_all()
        return
 
    def att_onoff(self, radio):
        self.attstate = self.att.get()
        if self.attstate:
            n1.connect("atton" + " " + radio)
        else:
            n1.connect("attoff" + " " + radio)
        self.get_all()
        return
 
 
    def get_atten(self, radio):
        self.atten = n1.connect("getatt" + " " + radio)
        if self.atten == "1":
            self.cb_att.select()
        elif self.atten == "0":
            self.cb_att.deselect()
        return
 
    def get_name(self, radio):
        print radio
        self.all_names = n1.connect("listradios")
        self.radios = self.all_names.split()
        print self.radios
        self.name = self.radios[int(radio) - 1]
        self.name_l.set(self.name)
        return
 
    def graph_points(self):
        seq = self.smeter_list
        y_stretch = 1
        y_gap = 5
        x_stretch = 0
        x_width = 2
        x_gap = 2
        height = 100
        self.c1.delete(ALL)
        self.c1.create_line(0, 100 - (-73 + 123 + 5), 310, 100 - (-73 + 123 + 5), fill='white')
        for x, y in enumerate(seq):
            yd = y + 123
            x0 = x * x_stretch + x * x_width + x_gap
            y0 = height - (yd * y_stretch + y_gap)
            x1 = x * x_stretch + x * x_width + x_width + x_gap
            y1 = height - y_gap
            self.c1.create_rectangle(x0, y0, x1, y1, fill="yellow")
 
    def write_file(self):
        self.filename = self.name+".txt"
        self.f = open(self.filename, 'a+')
        timenow = time.strftime("%d/%m/%Y %H:%M:%S", time.gmtime(time.time()))
        log = " ".join((timenow, self.name, self.mode, self.freq, self.smeter, self.preamp, self.atten, "\r\n"))
        self.f.write(log)
        self.f.close()
 
def update():
    #loops = 0
 
    try:
        nRadio1.get_all()
    except:
        pass
    try:
        nRadio2.get_all()
    except:
        pass
    try:
        nRadio3.get_all()
    except:
        pass
    try:
        nRadio4.get_all()
    except:
        pass
    d1.up_dash()
    return
 
def main():
    #loops = 0
    while True:
        try:
            nRadio1.get_all()
        except:
            pass
        try:
            nRadio2.get_all()
        except:
            pass
        try:
            nRadio3.get_all()
        except:
            pass
        try:
            nRadio4.get_all()
        except:
            pass
        d1.up_dash()
        #loops += 1
        #print threading.currentThread().name, loops
        time.sleep(5)
 
def close():
    n1.connect("quit")
    root.destroy()
 
 
if __name__ == "__main__":
    version = "v0.4"
    lock = threading.Lock()
    root = Tk()
    #w, h = root.winfo_screenwidth(), root.winfo_screenheight()
    #root.geometry("%dx%d+0+0" % (w, h))
    #root.geometry("300x520+0+0")
    root.title("Netradio " + version)
    #root.withdraw()
    n1 = Network()
    #radio_count = (n1.connect("count"))
    #radio_count = 3
 
    radio_count = int(n1.connect("count"))
    if radio_count > 0:
        nRadio1 = nRadio(root, "1")
    if radio_count > 1:
        nRadio2 = nRadio(root, "2")
    if radio_count > 2:
        nRadio3 = nRadio(root, "3")
    if radio_count > 3:
        nRadio4 = nRadio(root, "4")
 
    d1 = Dash(root)
 
    #print threading.currentThread().name
    #m1 = threading.Thread(target = main)
    #m1.setDaemon(True)
    #m1.start()
 
    update()
 
    root.mainloop()

S-meter display version

gui.py

gui.py

# # new class-based gui
 
from Tkinter import *
import socket
import threading
import time
 
 
 
class Network(object):
    def __init__(self):
        self.sock = self.make_con()
 
    def make_con(self):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.connect(("192.168.21.107", 9999))
        return self.sock
 
    def connect(self, data):
        try:
            lock.acquire()
            self.sock.sendall(data + "\n")
            self.received = self.sock.recv(2048)
        finally:
            lock.release()
            return self.received
 
class Dash(object):
    def __init__(self, master):
        self.master = master
 
        self.s = (n1.sock.getsockname())
        self.p = (n1.sock.getpeername())
 
 
 
        dash_frame = Toplevel(master, borderwidth = 2, relief = GROOVE, bg = 'black')
        dash_frame.title("Server")
        dash_frame.protocol("WM_DELETE_WINDOW", self.handler)
        dash_frame.resizable(0, 0)
        dash_frame.geometry("300x150-10+10")
        dash_frame.grid()
 
        self.utc_time = StringVar()
        Label(dash_frame, textvariable = self.utc_time, fg = 'green', bg = 'black').grid(row = 0, column = 0, sticky = W)
 
        Label(dash_frame, text = self.s, bg = 'black', fg = 'white').grid(row = 1, column = 0, sticky = W)
 
        Label(dash_frame, text = " < --- > ", bg = 'black', fg = 'white').grid(row = 1, column = 1)
 
        Label(dash_frame, text = self.p, bg = 'black', fg = 'white').grid(row = 1, column = 2, sticky = E)
 
        self.server_msg_l = StringVar()
        Label(dash_frame, textvariable = self.server_msg_l, fg = 'yellow', bg = 'black').grid(row = 2, column = 0, columnspan = 3, sticky = W)
 
        q_button = Button(dash_frame, text = "Quit", command = lambda: close())
        q_button.grid(row = 3, column = 0, sticky = W)
 
    def handler(self):
        pass
 
    def up_dash(self):
        self.server_msg = n1.connect("ident")
        self.server_msg_l.set(self.server_msg)
        self.utc_time.set(time.strftime("%d/%m/%Y %H:%M", time.gmtime(time.time())))
        return
 
class nRadio(object):
    def __init__(self, master, radio):
        self.master = master
 
        self.radio = radio
        self.num = "".join(("r", self.radio))
 
 
        radio_frame = Frame(master, borderwidth=2, relief=GROOVE)
 
        radio_frame.grid()
        self.smeter_list = []
 
        Label(radio_frame, text="Name", width=10).grid(row=0, column=0)
        Label(radio_frame, text="Freq/kHz", width=10).grid(row=0, column=1)
        Label(radio_frame, text="Mode", width=10).grid(row=0, column=2)
        Label(radio_frame, text="Signal/dBm", width=10).grid(row=0, column=3)
        Label(radio_frame, text="Max/dBm", width=10, fg='red').grid(row=0, column=4)
        Label(radio_frame, text="Ave/dBm", width=10, fg='green').grid(row=0, column=5)
        Label(radio_frame, text="Min/dBm", width=10, fg='blue').grid(row=0, column=6)
 
        self.name_l = StringVar()
        self.l_name = Label(radio_frame, textvariable=self.name_l, width=10)
        self.l_name.grid(row=1, column=0, sticky=W)
 
        self.freq_l = StringVar()
        self.l_freq = Label(radio_frame, fg='red', textvariable=self.freq_l, width=10)
        self.l_freq.grid(row=1, column=1, sticky=E)
 
        self.mode_l = StringVar()
        self.l_mode = Label(radio_frame, textvariable=self.mode_l, width=10)
        self.l_mode.grid(row=1, column=2, sticky=E)
        '''
        self.e_mode = Entry(radio_frame, width=10, bg = 'white', fg = 'black', insertbackground = 'blue')
        self.e_mode.grid(row=2, column=2)
        self.e_mode.bind('<Return>', (lambda event: self.set_mode(self.num)))
        '''
        #self.e_mode = StringVar()
        self.b_mode_usb = Button(radio_frame, text = "USB", width = 4, command = lambda: self.set_mode("usb", self.num))
        self.b_mode_usb.grid(row = 3, column = 0)
 
        self.b_mode_lsb = Button(radio_frame, text = "LSB", width = 4, command = lambda: self.set_mode("lsb", self.num))
        self.b_mode_lsb.grid(row = 3, column = 1)
 
        self.b_mode_cw = Button(radio_frame, text = "CW", width = 4, command = lambda: self.set_mode("cw", self.num))
        self.b_mode_cw.grid(row = 4, column = 0)
 
        self.b_mode_am = Button(radio_frame, text = "AM", width = 4, command = lambda: self.set_mode("am", self.num))
        self.b_mode_am.grid(row = 4, column = 1)
 
        self.b_mode_data = Button(radio_frame, text = "Data", width = 4, command = lambda: self.set_mode("data", self.num))
        self.b_mode_data.grid(row = 3, column = 2)
 
        self.smeter_l = StringVar()
        self.l_smeter = Label(radio_frame, textvariable=self.smeter_l, width=10)
        self.l_smeter.grid(row=1, column=3, sticky=E)
 
        self.max_var = StringVar()
        self.l_max = Label(radio_frame, textvariable=self.max_var, width=10)
        self.l_max.grid(row=1, column=4)
 
        self.ave_var = StringVar()
        self.l_average = Label(radio_frame, textvariable=self.ave_var, width=10)
        self.l_average.grid(row=1, column=5)
 
        self.min_var = StringVar()
        self.l_min = Label(radio_frame, textvariable=self.min_var, width=10)
        self.l_min.grid(row=1, column=6)
 
        self.e_freq = Entry(radio_frame, width=10, bg = 'white', fg = 'black', insertbackground = 'blue')
        self.e_freq.grid(row=2, column=1)
        self.e_freq.focus()
        self.e_freq.bind('<Return>', (lambda event: self.set_freq(self.num)))
 
 
 
        self.pre = IntVar()
        self.cb_pre = Checkbutton(radio_frame, variable=self.pre, command=lambda: self.preamp_onoff(self.num))
        self.cb_pre.grid(row=5, column=4, sticky=E)
 
        self.l_pre = Label(radio_frame, width=10, text="Preamp")
        self.l_pre.grid(row=5, column=3, sticky=W)
 
        self.att = IntVar()
        self.cb_att = Checkbutton(radio_frame, variable=self.att, command=lambda: self.att_onoff(self.num))
        self.cb_att.grid(row=6, column=4, sticky=E)
 
        self.l_att = Label(radio_frame, width=10, text="Att")
        self.l_att.grid(row=6, column=3, sticky=W)
 
        self.set_log = IntVar()
        self.cb_log = Checkbutton(radio_frame, variable = self.set_log)
        self.cb_log.grid(row = 6, column = 1, sticky = W)
 
        self.l_log = Label(radio_frame, width = 10, text = "Log to file...")
        self.l_log.grid(row = 6, column = 0, sticky = E)
 
        self.c1 = Canvas(radio_frame, width=260, height=100, bg='black')
        self.c1.grid(row=2, column=3, columnspan=4, rowspan=3)
 
        name = self.get_name(radio)
 
 
    def get_all(self):
 
        self.get_freq(self.num)
        self.get_mode(self.num)
        self.get_smeter(self.num)
        self.get_preamp(self.num)
        self.get_atten(self.num)
        self.graph_points()       
        self.avg()
        self.max()
        self.min()
 
        if self.set_log.get() == 1:
            if int(time.time()) % 10.0 == 0:
                self.write_file()
        return
 
    def get_freq(self, radio):
 
        self.freq = n1.connect("getfreq" + " " + radio)
        self.freq_l.set(self.freq)
        return
 
    def set_freq(self, radio):
        self.freq = str(self.e_freq.get())
        self.newfreq = n1.connect("setfreq" + " " + self.freq + " " + radio)
        self.e_freq.delete(0, END)
 
        return
 
    def get_mode(self, radio):
        self.mode = n1.connect("getmode" + " " + radio)
        self.mode_l.set(self.mode)
        return
 
    def set_mode(self, mode, radio):
        #self.mode = str(self.e_mode.get())
        self.newmode = n1.connect("setmode" + " " + mode + " " + radio)
        #self.e_mode.delete(0, END)
        return
 
    def get_smeter(self, radio):
        self.smeter = n1.connect("getsmeter" + " " + radio)
        self.smeter_l.set(self.smeter)
        self.smeter_list.append(float(self.smeter))
        if len(self.smeter_list) > 120:
            self.smeter_list.pop(0)
        return
 
    def avg(self):
        s = self.smeter_list
        total = 0
        for i in s:
            total += i
        self.av = round((total / len(s)), 1)
        self.ave_var.set(str(self.av))
        self.c1.create_line(0, 100 - (self.av + 123 + 5), 310, 100 - (self.av + 123 + 5), fill="green")
        return self.av
 
    def min(self):
        s = self.smeter_list
        self.mn = s[0]
        for i in s:
            if i < self.mn:
                self.mn = i
        self.min_var.set(str(self.mn))
        self.c1.create_line(0, 100 - (self.mn + 123 + 5), 310, 100 - (self.mn + 123 + 5), fill="blue")
        return self.mn
 
    def max(self):
        s = self.smeter_list
        self.mx = s[0]
        for i in s:
            if i > self.mx:
                self.mx = i
        self.max_var.set(str(self.mx))
        self.c1.create_line(0, 100 - (self.mx + 123 + 5), 310, 100 - (self.mx + 123 + 5), fill="red")
        return self.mx
 
    def get_preamp(self, radio):
        self.preamp = n1.connect("getpreamp" + " " + radio)
        if self.preamp == "1":
            self.cb_pre.select()
        elif self.preamp == "0":
            self.cb_pre.deselect()
        return
 
    def preamp_onoff(self, radio):
        self.prestate = self.pre.get()
        if self.prestate:
            n1.connect("preampon" + " " + radio)
        else:
            n1.connect("preampoff" + " " + radio)
        return
 
    def att_onoff(self, radio):
        self.attstate = self.att.get()
        if self.attstate:
            n1.connect("atton" + " " + radio)
        else:
            n1.connect("attoff" + " " + radio)
        return
 
 
    def get_atten(self, radio):
        self.atten = n1.connect("getatt" + " " + radio)
        if self.atten == "1":
            self.cb_att.select()
        elif self.atten == "0":
            self.cb_att.deselect()
        return
 
    def get_name(self, radio):
        print radio
        self.all_names = n1.connect("listradios")
        self.radios = self.all_names.split()
        print self.radios
        self.name = self.radios[int(radio) - 1]
        self.name_l.set(self.name)
        return
 
    def graph_points(self):
        seq = self.smeter_list
        y_stretch = 1
        y_gap = 5
        x_stretch = 0
        x_width = 2
        x_gap = 2
        height = 100
        self.c1.delete(ALL)
        self.c1.create_line(0, 100 - (-73 + 123 + 5), 310, 100 - (-73 + 123 + 5), fill='white')
        for x, y in enumerate(seq):
            yd = y + 123
            x0 = x * x_stretch + x * x_width + x_gap
            y0 = height - (yd * y_stretch + y_gap)
            x1 = x * x_stretch + x * x_width + x_width + x_gap
            y1 = height - y_gap
            self.c1.create_rectangle(x0, y0, x1, y1, fill="yellow")
 
    def write_file(self):
        self.filename = self.name+".txt"
        self.f = open(self.filename, 'a+')
        timenow = time.strftime("%d/%m/%Y %H:%M:%S", time.gmtime(time.time()))
        log = " ".join((timenow, self.name, self.mode, self.freq, self.smeter, self.preamp, self.atten, "\r\n"))
        self.f.write(log)
        self.f.close()
 
 
 
def main():
    #loops = 0
    while True:
        try:
            nRadio1.get_all()
        except:
            pass
        try:
            nRadio2.get_all()
        except:
            pass
        try:
            nRadio3.get_all()
        except:
            pass
        try:
            nRadio4.get_all()
        except:
            pass
        d1.up_dash()
        #loops += 1
        #print threading.currentThread().name, loops
        time.sleep(1)
 
def close():
    n1.connect("quit")
    root.destroy()
 
 
if __name__ == "__main__":
    version = "v0.3"
    lock = threading.Lock()
    root = Tk()
    #w, h = root.winfo_screenwidth(), root.winfo_screenheight()
    #root.geometry("%dx%d+0+0" % (w, h))
    root.geometry("550x600+0+0")
    root.title("GM4SLV Radio Controller " + version)
    #root.withdraw()
    n1 = Network()
    #radio_count = (n1.connect("count"))
    #radio_count = 3
 
    radio_count = int(n1.connect("count"))
    if radio_count > 0:
        nRadio1 = nRadio(root, "1")
    if radio_count > 1:
        nRadio2 = nRadio(root, "2")
    if radio_count > 2:
        nRadio3 = nRadio(root, "3")
    if radio_count > 3:
        nRadio4 = nRadio(root, "4")
 
    d1 = Dash(root)
 
    #print threading.currentThread().name
    m1 = threading.Thread(target = main)
    m1.setDaemon(True)
    m1.start()
 
 
 
    root.mainloop()

Further Information

OFCOM

anonymous@undisclosed.example.com (Anonymous) — Thu, 04 Jun 2026 06:39:56 +0000

←Radio Topics

OFCOM

Login to OFCOM online

https://ofcom.force.com/licensingcomlogin

Licence Details

GM4SLV Amateur Radio

Issued as G4SLV : March 1983

OFCOM Validation Details

Date	Licence Number	Validation Document	Next Due
01/07/2023	1-8513-93392/3	GM4SLV	July 2028

Business Radio Simple

OFCOM Licence Details

Surrendered 1 July 2023. Renewal was due and I couldn't justify the cost as the licence has not been used often enough in the 5 years since issue.

Date	Licence Number	Validation Document	Renewal Due
11/07/18	BR0005251	BRS Licence	31/07/23

Frequencies

Low Band	Mid Band	High Band	UHF 1
77.6875 MHz	164.0500 MHz	169.0875 MHz	449.3125 MHz
86.3375 MHz	164.0625 MHz	169.3125 MHz	449.4000 MHz
86.3500 MHz		173.0500 MHz	449.4750 MHz
86.3625 MHz		173.0625 MHz	458.7875 MHz
86.3750 MHz		173.0875 MHz	458.8000 MHz
			458.8125 MHz
			458.8250 MHz

— John Pumford-Green 01/06/22 13:13

Page last updated: 04/06/26 07:39 BST

radio

QSO Logging

anonymous@undisclosed.example.com (Anonymous) — Thu, 04 Jun 2026 18:15:51 +0000

←Radio Topics

QSO Logging

2023 Logging setup

Paper Logbook

I've always (when I remember) used a Paper Logbook for CW and SSB contacts. I'm on the third book after starting the 1st one in March 1983.

I usually don't (but sometimes do) log Digimode QSOs on paper, as fldigi has its own ADIF logbook. However I've moved/installed/upgraded/deleted various fldigi installations on so many different PCs that I've actually lost all the logs anyway. I've recently started logging all QSOs in the paper logbook. There's no chance of “accidentally deleting” a real, paper logbook, after all.

Update July 2023

I initially started to make notes of each day's activity and QSOs here, in the wiki
This became a chore, too many separate things to do during/after a QSO
I ditched the wiki-diary idea but want to have more of a record of QSOs, and other notes on condx etc. than a simple one line entry in the logbook
I started keeping a paper “journal” - basically a more carefully created scratch-pad - with entries being done during the QSO - my notes done at the time.
The left hand page of the spread is a scribble/rough notes area and the right hand page of the spread has notes of activity, CQs made, CQs replied to, QSOs, callsigns, propagation data (SFI, A, K etc), beacons heard, anything really.
I still add an entry to both paper logbook and Xlog, but they don't need too much additional detail, as it's all in the “journal”

Electronic Logs

I've tried various PC based log systems over the years. A few years ago I had a major project to add all the old data from my paper logs into an electronic log - I think I used “logger32” on a windows PC. I started from August 2003, the date I re-activated my dormant interest in amateur radio, and I built my Elecraft K1.

I count this as “day zero” of my current radio incarnation.

I could then export the ADIF file and could use it to “pre-populate” any new log system I fancied trying.

I now use xlog on my shack's old Linux laptop. It has all the QSO data from August 2003 to the present (except most Digimode QSOs) and I continue to use xlog in parallel with a good old fashioned paper logbook.

I have also discovered that fldigi will automatically add each logged QSO to Xlog, if they are running on the same machine, which means I can now ensure my digimode QSOs are recorded alongside my CW and SSB QSOs.

As of August 26th 2023 I no longer keep an electronic log.

I have ceased LOTW uploads. QSLs are now direct only if anyone wants/needs confirmation of a QSO

LOTW

While I was adding all my historical QSO data to an electronic log I decided to “join” the ARRL Logbook Of The World and add my QSO data. I did it in various stages, but I think I've now got all my QSO records uploaded to LOTW. This is mainly to assist others in their paper chasing goals, as I'm not generally interested in getting QSLs in order to claim awards (I've only got 84 DXCC “confirmed” on LOTW for “Mixed”, with 65 in Phone and 65 in CW). If my uploads allow other people to reach targets, without me needing to write and post physical QSL cards, then it's easy enough to oblige with LOTW. I had to download the sourcecode and compile the latest version of TQSL from the ARRL website to run on Linux. I forget how I got the necessary certificates from ARRL….

Club Log

~~I created a ClubLog account and I also upload my ADIF exports at regular intervals. I embed the “last 30” QSOs on my qrz.com page.~~

Update July 2023

I decided it's too cumbersome, and with no obvious benefit, to upload ADIF files to ClubLog as well as to LOTW
- ClubLog has no purpose, really, for me at the moment

Update August 28 2023

I have decided to drop ALL computer logging
- this means no LOTW either
I want a simpler radio shack, without reliance on computer for logging or any other purpose.
Logging : paper log book
Notes : on paper in separate “diary” made during QSO - these can be dated and kept as a reference
- Notes on radio setup, antennas, beacons etc., solar conditions etc. are in the same “diary” - as a record of day to day activity alongside any QSOs etc.
No RBN checking, no QRZ.COM checking.
Re-start card-index of stations worked, if not too time-consuming?

Workflow

~~start flrig & ensure correct communication with IC-7200~~
~~start fldigi & ensure it controls the IC-7200 via flrig~~
~~start xlog & ensure it shows the correct radio frequency (when the freq. log button is pressed)~~
have QSOs in ~~fldigi or~~ CW and log in paper logbook ~~as appropriate~~
~~export log ADIF file from xlog - selecting the latest QSO numbers, rather than the whole log~~
~~use TQSL to sign and upload this latest ADIF export to my LOTW account<?del> * <del>use the ClubLog website to upload this latest ADIF export to my CLubLog account~~

— John Pumford-Green 19/06/23 12:55

Further Information

Getting back into radio

anonymous@undisclosed.example.com (Anonymous) — Thu, 04 Jun 2026 06:39:56 +0000

←Radio Topics

Getting back into radio

I've got the radio bug again

HF

New HF antenna - simple vertical on a 10m Sota-Pole after the old Racal mast holding up the Inverted-L collapsed this winter
- improved ground/radials (6/4/25)…. more work to be done
Going back to “the old days” where I used 'phone more often
Putting aside the CW keys/bugs for a while
- and also digimodes put to one side
New HF Rig : FT-891 for SSB and 10m FM 'phone operation
Portable “go box” with G90 being re-assembled
- New 7m Sota-Pole for portable operation

Other bands/modes

DMR back online at home
- Full Duplex 2-timeslot hotspot
- Anytone 878
2m APRS I-Gate running again GM4SLV-2
VHF and APRS mobile GM4SLV-9 with TM-D710

— John Pumford-Green 06/04/25 08:31 BST

Further Information

radio

Raspberry Pi Farm

anonymous@undisclosed.example.com (Anonymous) — Thu, 04 Jun 2026 20:39:30 +0000

←Radio Topics

Raspberry Pi Farm

I seem to collect Raspberry Pis - not sure if they breed when you put them away in a box while waiting for a new project….

Gone but not forgotten

Pi number	Main Use	Callsign	Hardware interface	Main software	Frequency
VHF / HF X-Gate Project	X-Gate		Homebrew X-gate	Python xgate	HF ⇔ VHF (QRT at present)
DMR HotSpots	Pi-Star DMR Hotspot	235442901	DVMega	Pi-Star	438.800MHz
GM4SLV Allstar	AllStar Gateway	GM4SLV	CM108 soundcard FT-8900	Asterisk	430.050MHz
APRS	APRS iGate	GM4SLV-2	TNC-Pi	aprx or dixprs	144.800MHz
svxlink hotspot	SVXLink Gateway	GM4SLV	CM108 soundcard IC-2E	SVXLink	144.600MHz
Openweb SDR	Web SDR		Funcube Dongle Pro+	Openwebrx	HF Bands

—- John Pumford-Green Wed May 4 10:23:56 2022

Page Updated : 04/06/26 21:39 BST

radio, pi, linux

Openweb SDR

anonymous@undisclosed.example.com (Anonymous) — Thu, 04 Jun 2026 18:33:10 +0000

←Radio Topics

Openweb SDR

Hardware

Platform	Raspberry Pi
SDR	Funcube Dongle Pro+
Antenna	Wellbrook ALA1530 Loop

Network Access

Accessible as http://gm4slv.plus.com:8073

and listed at Receiverbook too….

Shack 2023

anonymous@undisclosed.example.com (Anonymous) — Thu, 04 Jun 2026 18:16:54 +0000

←Radio Topics

Shack 2023

Changes to Shack layout over time

18/06/23 - operating CW

Operating Bench

Work Bench

— John Pumford-Green 18/06/23 16:12

Further Information

radio

Radio Topics

anonymous@undisclosed.example.com (Anonymous) — Thu, 04 Jun 2026 20:43:07 +0000

←Radio

Radio Topics

Various Projects

A collection of pages about things I've tinkered with over the last few years.

The pages here are for information and to help should I want to re-visit any of the subjects/projects.

— John Pumford-Green 26/04/23 13:41

Make It Tea - public:radio:topics

4m FM

4m FM

Background

Frequencies

SIC Roads PMR

4m Amateur Band

Business Radio Simple Light

Further Information

10m/12m

10m/12m

Equipment

Antenna

Propagation Data

10m WSPR Spots vs SFI & K indices

Further Information

60m

60m

Band Utilization

USA

Canada

UK : Occupancy versus Bandlet/channel

UK Bandlet List

Other 60m Users

Further Information

Exercise Blue Ham 2024

The next Blue Ham is

60m band Wikipedia Page

CCIR493 Selcall

CCIR493 Selcall

Background

Basic details

Jenal SC2 Mic

Scanning

Previous Selcall Activity

Selcall Activity 2023

Further Information

Code snippets

CW 2023

CW 2023

Current Setup

Plans

Receive Practice

Further Information

DMR and DV Modes

DMR and DV Modes

Hotspots

Radios

Further Information

DMR Dashboards

DMR HotSpots

DMR HotSpots

Update 3/10/22

See Also

Fldigi Parrot

Fldigi Parrot

Experimental HF Digi-mode message-relay system using Fldigi and Python

Work in progress

Monitoring

Software

tmux script

rx_buf.py

parrot_flmsg.py

flfn.py

Parrot Operation

Basic overview

Further examples of operation

K2 2023

K2 2023

Background

Order

Progress

Order Cancelled

Further Information

Netradio Control

Netradio Control

Server

Server

Configurtion Module

Icom C-IV module