def command_set_mode(self, active_command):
""" Sets the radio's mode and updates the driver's state appropriately.
@note Currently, this command can only set the mode to: "FM"
@throws Raises CommandError if the command fails for some reason.
@param active_command The executing Command. Contains the command parameters.
@return Returns a dictionary containing the command response.
"""
if self.radio_rig is not None:
if 'mode' in active_command.parameters:
# Set the mode in Hamlib
new_mode = active_command.parameters['mode']
if new_mode == "FM":
response = self.radio_rig.set_mode(Hamlib.RIG_MODE_FM)
else:
raise command.CommandError("An unrecognized mode was specified.")
# Check for errors
if response is not Hamlib.RIG_OK:
raise command.CommandError("An error occured setting the radio's mode.")
# Get the mode and update the driver state
mode, width = self.radio_rig.get_mode()
self.driver._radio_state['mode'] = Hamlib.rig_strrmode(mode)
return {'message': "The radio mode has been set.", 'mode': new_mode}
else:
raise command.CommandError("No mode specified for the 'set_mode' command.")
else:
raise command.CommandError("The "+self.driver.id+" command handler does not have an initialized Hamlib rig.")
def hamlib_autofill(self, rig_model, rig_pathname):
""" Set the various fields using data from the radio via Hamlib.
:arg str rig_model: The model of the radio/rig.
:arg str rig_pathname: The path to the rig (or rig control device).
"""
# Open a communication channel to the radio.
try:
Hamlib.rig_set_debug(Hamlib.RIG_DEBUG_NONE)
rig = Hamlib.Rig(Hamlib.__dict__[rig_model]) # Look up the model's numerical index in Hamlib's symbol dictionary.
rig.set_conf("rig_pathname", rig_pathname)
rig.open()
except:
logging.error("Could not open a communication channel to the rig via Hamlib!")
return
# Frequency
try:
frequency = "%.6f" % (rig.get_freq()/1.0e6) # Converting to MHz here.
# Convert to the desired unit, if necessary.
if(self.frequency_unit != "MHz"):
frequency = str(self.convert_frequency(frequency, from_unit="MHz", to_unit=self.frequency_unit))
self.sources["FREQ"].set_text(frequency)
except:
logging.error("Could not obtain the current frequency via Hamlib!")
# Mode
try:
(mode, width) = rig.get_mode()
mode = Hamlib.rig_strrmode(mode).upper()
# Handle USB and LSB as special cases.
if(mode == "USB" or mode == "LSB"):
submode = mode
mode = "SSB"
self.sources["MODE"].set_active(sorted(MODES.keys()).index(mode))
self.sources["SUBMODE"].set_active(MODES[mode].index(submode))
else:
self.sources["MODE"].set_active(sorted(MODES.keys()).index(mode))
except:
logging.error("Could not obtain the current mode (e.g. FM, AM, CW) via Hamlib!")
# Close communication channel.
try:
rig.close()
except:
logging.error("Could not close the communication channel to the rig via Hamlib!")
return
def get_capabilities():
""" Return a dictionary of rig capabilities.
"""
caps = {'models': [], 'rates': [], 'parities': [], 'modes': []}
is_int = lambda n: isinstance(n, int)
#FIXME WinRadio RIG_MODEL_G313 is causing problems on Linux machines - ignore for now
for model in [n for x, n in inspect.getmembers(Hamlib, is_int) if x.startswith('RIG_MODEL_') and x != 'RIG_MODEL_G313']:
rig = Hamlib.Rig(model)
if rig.this is None:
continue
caps['models'].append({
'model': model,
'manufacturer': rig.caps.mfg_name,
'name': rig.caps.model_name,
'version': rig.caps.version,
'status': Hamlib.rig_strstatus(rig.caps.status),
'modes': rig.state.mode_list
})
for n in xrange(int(math.log(Hamlib.RIG_MODE_TESTS_MAX - 1, 2))):
mode = 2 ** n
caps['modes'].append({'value': mode, 'label': Hamlib.rig_strrmode(mode)})
caps['rates'] = [{'value': 2400, 'label': '2400'},
{'value': 4800, 'label': '4800'},
{'value': 9600, 'label': '9600'},
{'value': 14400, 'label': '14.4k'},
{'value': 19200, 'label': '19.2k'},
{'value': 28800, 'label': '28.8k'}]
for x, n in inspect.getmembers(Hamlib, is_int):
if not x.startswith('RIG_PARITY_'):
continue
caps['parities'].append({'label': x[11:].capitalize(), 'value': n})
return caps
def StartUp():
"""Simple script to test the Hamlib.py module with Python3."""
print("%s: Python %s; %s\n" \
% (sys.argv[0], sys.version.split()[0], Hamlib.cvar.hamlib_version))
Hamlib.rig_set_debug(Hamlib.RIG_DEBUG_NONE)
# Init RIG_MODEL_DUMMY
my_rig = Hamlib.Rig(Hamlib.RIG_MODEL_DUMMY)
my_rig.set_conf("rig_pathname", "/dev/Rig")
my_rig.set_conf("retry", "5")
my_rig.open ()
# 1073741944 is token value for "itu_region"
# but using get_conf is much more convenient
region = my_rig.get_conf(1073741944)
rpath = my_rig.get_conf("rig_pathname")
retry = my_rig.get_conf("retry")
print("status(str):\t\t%s" % Hamlib.rigerror(my_rig.error_status))
print("get_conf:\t\tpath = %s, retry = %s, ITU region = %s" \
% (rpath, retry, region))
my_rig.set_freq(Hamlib.RIG_VFO_B, 5700000000)
my_rig.set_vfo(Hamlib.RIG_VFO_B)
print("freq:\t\t\t%s" % my_rig.get_freq())
my_rig.set_freq(Hamlib.RIG_VFO_A, 145550000)
(mode, width) = my_rig.get_mode()
print("mode:\t\t\t%s\nbandwidth:\t\t%s" % (Hamlib.rig_strrmode(mode), width))
my_rig.set_mode(Hamlib.RIG_MODE_CW)
(mode, width) = my_rig.get_mode()
print("mode:\t\t\t%s\nbandwidth:\t\t%s" % (Hamlib.rig_strrmode(mode), width))
print("ITU_region:\t\t%s" % my_rig.state.itu_region)
print("Backend copyright:\t%s" % my_rig.caps.copyright)
print("Model:\t\t\t%s" % my_rig.caps.model_name)
print("Manufacturer:\t\t%s" % my_rig.caps.mfg_name)
print("Backend version:\t%s" % my_rig.caps.version)
print("Backend status:\t\t%s" % Hamlib.rig_strstatus(my_rig.caps.status))
print("Rig info:\t\t%s" % my_rig.get_info())
my_rig.set_level("VOX", 1)
print("VOX level:\t\t%s" % my_rig.get_level_i("VOX"))
my_rig.set_level(Hamlib.RIG_LEVEL_VOX, 5)
print("VOX level:\t\t%s" % my_rig.get_level_i(Hamlib.RIG_LEVEL_VOX))
af = 12.34
print("Setting AF to %0.2f...." % (af))
my_rig.set_level("AF", af)
print("status:\t\t\t%s - %s" % (my_rig.error_status,
Hamlib.rigerror(my_rig.error_status)))
print("AF level:\t\t%0.2f" % my_rig.get_level_f(Hamlib.RIG_LEVEL_AF))
print("strength:\t\t%s" % my_rig.get_level_i(Hamlib.RIG_LEVEL_STRENGTH))
print("status:\t\t\t%s" % my_rig.error_status)
print("status(str):\t\t%s" % Hamlib.rigerror(my_rig.error_status))
chan = Hamlib.channel(Hamlib.RIG_VFO_B)
my_rig.get_channel(chan)
print("get_channel status:\t%s" % my_rig.error_status)
print("VFO:\t\t\t%s, %s" % (Hamlib.rig_strvfo(chan.vfo), chan.freq))
print("Attenuators:\t\t%s" % my_rig.caps.attenuator)
print("\nSending Morse, '73'")
my_rig.send_morse(Hamlib.RIG_VFO_A, "73")
my_rig.close()
print("\nSome static functions:")
err, lon1, lat1 = Hamlib.locator2longlat("IN98XC")
err, lon2, lat2 = Hamlib.locator2longlat("DM33DX")
err, loc1 = Hamlib.longlat2locator(lon1, lat1, 3)
err, loc2 = Hamlib.longlat2locator(lon2, lat2, 3)
print("Loc1:\t\tIN98XC -> %9.4f, %9.4f -> %s" % (lon1, lat1, loc1))
print("Loc2:\t\tDM33DX -> %9.4f, %9.4f -> %s" % (lon2, lat2, loc2))
err, dist, az = Hamlib.qrb(lon1, lat1, lon2, lat2)
longpath = Hamlib.distance_long_path(dist)
print("Distance:\t%.3f km, azimuth %.2f, long path:\t%.3f km" \
% (dist, az, longpath))
# dec2dms expects values from 180 to -180
# sw is 1 when deg is negative (west or south) as 0 cannot be signed
err, deg1, mins1, sec1, sw1 = Hamlib.dec2dms(lon1)
err, deg2, mins2, sec2, sw2 = Hamlib.dec2dms(lat1)
lon3 = Hamlib.dms2dec(deg1, mins1, sec1, sw1)
lat3 = Hamlib.dms2dec(deg2, mins2, sec2, sw2)
print('Longitude:\t%4.4f, %4d° %2d\' %2d" %1s\trecoded: %9.4f' \
% (lon1, deg1, mins1, sec1, ('W' if sw1 else 'E'), lon3))
print('Latitude:\t%4.4f, %4d° %2d\' %2d" %1s\trecoded: %9.4f' \
% (lat1, deg2, mins2, sec2, ('S' if sw2 else 'N'), lat3))
def hamlib_autofill(self, rig_model, rig_pathname):
""" Set the various fields using data from the radio via Hamlib.
:arg str rig_model: The model of the radio/rig.
:arg str rig_pathname: The path to the rig (or rig control device).
"""
# Open a communication channel to the radio.
try:
Hamlib.rig_set_debug(Hamlib.RIG_DEBUG_NONE)
rig = Hamlib.Rig(
Hamlib.__dict__[rig_model]
) # Look up the model's numerical index in Hamlib's symbol dictionary.
rig.set_conf("rig_pathname", rig_pathname)
rig.open()
except:
logging.error(
"Could not open a communication channel to the rig via Hamlib!"
)
return
# Frequency
try:
frequency = "%.6f" % (rig.get_freq() / 1.0e6
) # Converting to MHz here.
# Convert to the desired unit, if necessary.
if (self.frequency_unit != "MHz"):
frequency = str(
self.convert_frequency(frequency,
from_unit="MHz",
to_unit=self.frequency_unit))
self.sources["FREQ"].set_text(frequency)
except:
logging.error("Could not obtain the current frequency via Hamlib!")
# Mode
try:
(mode, width) = rig.get_mode()
mode = Hamlib.rig_strrmode(mode).upper()
# Handle USB and LSB as special cases.
if (mode == "USB" or mode == "LSB"):
submode = mode
mode = "SSB"
self.sources["MODE"].set_active(
sorted(self.modes.keys()).index(mode))
self.sources["SUBMODE"].set_active(
self.modes[mode].index(submode))
else:
self.sources["MODE"].set_active(
sorted(self.modes.keys()).index(mode))
except:
logging.error(
"Could not obtain the current mode (e.g. FM, AM, CW) via Hamlib!"
)
# Close communication channel.
try:
rig.close()
except:
logging.error(
"Could not close the communication channel to the rig via Hamlib!"
)
return
def StartUp():
print "Python", sys.version[:5], "test,", Hamlib.cvar.hamlib_version, "\n"
#Hamlib.rig_set_debug (Hamlib.RIG_DEBUG_TRACE)
Hamlib.rig_set_debug(Hamlib.RIG_DEBUG_NONE)
# Init RIG_MODEL_DUMMY
my_rig = Hamlib.Rig(Hamlib.RIG_MODEL_DUMMY)
my_rig.set_conf("rig_pathname", "/dev/Rig")
my_rig.set_conf("retry", "5")
my_rig.open()
# 1073741944 is token value for "itu_region"
# but using get_conf is much more convenient
region = my_rig.get_conf(1073741944)
rpath = my_rig.get_conf("rig_pathname")
retry = my_rig.get_conf("retry")
print "status(str):\t\t", Hamlib.rigerror(my_rig.error_status)
print "get_conf:\t\tpath = %s, retry = %s, ITU region = %s" \
% (rpath, retry, region)
my_rig.set_freq(Hamlib.RIG_VFO_B, 5700000000)
my_rig.set_vfo(Hamlib.RIG_VFO_B)
print "freq:\t\t\t", my_rig.get_freq()
my_rig.set_freq(Hamlib.RIG_VFO_A, 145550000)
#my_rig.set_vfo ("VFOA")
(mode, width) = my_rig.get_mode()
print "mode:\t\t\t", Hamlib.rig_strrmode(mode), "\nbandwidth:\t\t", width
my_rig.set_mode(Hamlib.RIG_MODE_CW)
(mode, width) = my_rig.get_mode()
print "mode:\t\t\t", Hamlib.rig_strrmode(mode), "\nbandwidth:\t\t", width
print "ITU_region:\t\t", my_rig.state.itu_region
print "Backend copyright:\t", my_rig.caps.copyright
print "Model:\t\t\t", my_rig.caps.model_name
print "Manufacturer:\t\t", my_rig.caps.mfg_name
print "Backend version:\t", my_rig.caps.version
print "Backend license:\t", my_rig.caps.copyright
print "Rig info:\t\t", my_rig.get_info()
my_rig.set_level("VOX", 1)
print "VOX level:\t\t", my_rig.get_level_i("VOX")
my_rig.set_level(Hamlib.RIG_LEVEL_VOX, 5)
print "VOX level:\t\t", my_rig.get_level_i(Hamlib.RIG_LEVEL_VOX)
print "strength:\t\t", my_rig.get_level_i(Hamlib.RIG_LEVEL_STRENGTH)
print "status:\t\t\t", my_rig.error_status
print "status(str):\t\t", Hamlib.rigerror(my_rig.error_status)
chan = Hamlib.channel(Hamlib.RIG_VFO_B)
my_rig.get_channel(chan)
print "get_channel status:\t", my_rig.error_status
print "VFO:\t\t\t", Hamlib.rig_strvfo(chan.vfo), ", ", chan.freq
print "Attenuators:\t\t", my_rig.caps.attenuator
print "\nSending Morse, '73'"
my_rig.send_morse(Hamlib.RIG_VFO_A, "73")
my_rig.close()
print "\nSome static functions:"
err, lon1, lat1 = Hamlib.locator2longlat("IN98XC")
err, lon2, lat2 = Hamlib.locator2longlat("DM33DX")
err, loc1 = Hamlib.longlat2locator(lon1, lat1, 3)
err, loc2 = Hamlib.longlat2locator(lon2, lat2, 3)
print "Loc1:\t\tIN98XC -> %9.4f, %9.4f -> %s" % (lon1, lat1, loc1)
print "Loc2:\t\tDM33DX -> %9.4f, %9.4f -> %s" % (lon2, lat2, loc2)
err, dist, az = Hamlib.qrb(lon1, lat1, lon2, lat2)
longpath = Hamlib.distance_long_path(dist)
print "Distance:\t%.3f km, azimuth %.2f, long path:\t%.3f km" \
% (dist, az, longpath)
# dec2dms expects values from 180 to -180
# sw is 1 when deg is negative (west or south) as 0 cannot be signed
err, deg1, mins1, sec1, sw1 = Hamlib.dec2dms(lon1)
err, deg2, mins2, sec2, sw2 = Hamlib.dec2dms(lat1)
lon3 = Hamlib.dms2dec(deg1, mins1, sec1, sw1)
lat3 = Hamlib.dms2dec(deg2, mins2, sec2, sw2)
print 'Longitude:\t%4.4f, %4d° %2d\' %2d" %1s\trecoded: %9.4f' \
% (lon1, deg1, mins1, sec1, ('W' if sw1 else 'E'), lon3)
print 'Latitude:\t%4.4f, %4d° %2d\' %2d" %1s\trecoded: %9.4f' \
% (lat1, deg2, mins2, sec2, ('S' if sw2 else 'N'), lat3)
# Init setup for IC-R20
#my_rig = Hamlib.Rig (Hamlib.RIG_MODEL_ICR20)
my_rig = Hamlib.Rig (radioType)
my_rig.set_conf ("rig_pathname","/dev/icomCiv") #this is called icomCiv for historical reasons
my_rig.set_conf ("retry","5")
my_rig.open ()
my_rig.set_vfo (Hamlib.RIG_VFO_A)
my_rig.set_freq (radioFrequency)
print "freq:",my_rig.get_freq()
my_rig.set_mode(Hamlib.RIG_MODE_WFM)
(mode, width) = my_rig.get_mode()
print "mode:",Hamlib.rig_strrmode(mode),", bandwidth:",width
state = 'IDLE'
startTimer = START_TIME
stopTimer = STOP_TIME
timeCounter = 0 # This counter the number of seconds of transmission. Cull files > 30 seconds
while True :
rssi = my_rig.get_level_i(Hamlib.RIG_LEVEL_STRENGTH) + RSSI_OFFSET
if state == 'IDLE' :
print 'IDLE=> RSSI: {}'.format(rssi)
if rssi > RSSI_THRESHOLD : # Squelch open
state = 'START_TIMER'
startTimer = START_TIME
def StartUp ():
print "Python",sys.version[:5],"test,", Hamlib.cvar.hamlib_version
#Hamlib.rig_set_debug (Hamlib.RIG_DEBUG_TRACE)
Hamlib.rig_set_debug (Hamlib.RIG_DEBUG_NONE)
# Init RIG_MODEL_DUMMY
my_rig = Hamlib.Rig (Hamlib.RIG_MODEL_DUMMY)
my_rig.set_conf ("rig_pathname","/dev/Rig")
my_rig.set_conf ("retry","5")
my_rig.open ()
# 1073741944 is token value for "itu_region"
# but using get_conf is much more convenient
region = my_rig.get_conf(1073741944)
rpath = my_rig.get_conf("rig_pathname")
retry = my_rig.get_conf("retry")
print "status(str):",Hamlib.rigerror(my_rig.error_status)
print "get_conf: path=",rpath,", retry =",retry,", ITU region=",region
my_rig.set_freq (5700000000,Hamlib.RIG_VFO_B)
print "freq:",my_rig.get_freq()
my_rig.set_freq (145550000)
my_rig.set_vfo (Hamlib.RIG_VFO_B)
#my_rig.set_vfo ("VFOA")
(mode, width) = my_rig.get_mode()
print "mode:",Hamlib.rig_strrmode(mode),", bandwidth:",width
my_rig.set_mode(Hamlib.RIG_MODE_CW)
(mode, width) = my_rig.get_mode()
print "mode:",Hamlib.rig_strrmode(mode),", bandwidth:",width
print "ITU_region: ",my_rig.state.itu_region
print "Backend copyright: ",my_rig.caps.copyright
print "Model:",my_rig.caps.model_name
print "Manufacturer:",my_rig.caps.mfg_name
print "Backend version:",my_rig.caps.version
print "Backend license:",my_rig.caps.copyright
print "Rig info:", my_rig.get_info()
my_rig.set_level ("VOX", 1)
print "VOX level: ",my_rig.get_level_i("VOX")
my_rig.set_level (Hamlib.RIG_LEVEL_VOX, 5)
print "VOX level: ", my_rig.get_level_i(Hamlib.RIG_LEVEL_VOX)
print "strength: ", my_rig.get_level_i(Hamlib.RIG_LEVEL_STRENGTH)
print "status: ",my_rig.error_status
print "status(str):",Hamlib.rigerror(my_rig.error_status)
chan = Hamlib.channel(Hamlib.RIG_VFO_B)
my_rig.get_channel(chan)
print "get_channel status: ",my_rig.error_status
print "VFO: ",Hamlib.rig_strvfo(chan.vfo),", ",chan.freq
my_rig.close ()
print "\nSome static functions:"
err, long1, lat1 = Hamlib.locator2longlat("IN98EC")
err, long2, lat2 = Hamlib.locator2longlat("DM33DX")
err, loc1 = Hamlib.longlat2locator(long1, lat1, 3)
err, loc2 = Hamlib.longlat2locator(long2, lat2, 3)
print "Loc1: IN98EC -> ",loc1
print "Loc2: DM33DX -> ",loc2
# TODO: qrb should normalize?
err, dist, az = Hamlib.qrb(long1, lat1, long2, lat2)
if az > 180:
az -= 360
longpath = Hamlib.distance_long_path(dist)
print "Distance: ",dist," km, long path: ",longpath
err, deg, min, sec, sw = Hamlib.dec2dms(az)
az2 = Hamlib.dms2dec(deg, min, sec, sw)
if sw:
deg = -deg
print "Bearing: ",az,", ",deg,"° ",min,"' ",sec,", recoded: ",az2
def StartUp ():
print "Python", sys.version[:5], "test,", Hamlib.cvar.hamlib_version, "\n"
#Hamlib.rig_set_debug (Hamlib.RIG_DEBUG_TRACE)
Hamlib.rig_set_debug (Hamlib.RIG_DEBUG_NONE)
# Init RIG_MODEL_DUMMY
my_rig = Hamlib.Rig (Hamlib.RIG_MODEL_DUMMY)
my_rig.set_conf ("rig_pathname","/dev/Rig")
my_rig.set_conf ("retry","5")
my_rig.open ()
# 1073741944 is token value for "itu_region"
# but using get_conf is much more convenient
region = my_rig.get_conf(1073741944)
rpath = my_rig.get_conf("rig_pathname")
retry = my_rig.get_conf("retry")
print "status(str):\t\t",Hamlib.rigerror(my_rig.error_status)
print "get_conf:\t\tpath = %s, retry = %s, ITU region = %s" \
% (rpath, retry, region)
my_rig.set_freq (Hamlib.RIG_VFO_B, 5700000000)
my_rig.set_vfo (Hamlib.RIG_VFO_B)
print "freq:\t\t\t",my_rig.get_freq()
my_rig.set_freq (Hamlib.RIG_VFO_A, 145550000)
#my_rig.set_vfo ("VFOA")
(mode, width) = my_rig.get_mode()
print "mode:\t\t\t",Hamlib.rig_strrmode(mode),"\nbandwidth:\t\t",width
my_rig.set_mode(Hamlib.RIG_MODE_CW)
(mode, width) = my_rig.get_mode()
print "mode:\t\t\t",Hamlib.rig_strrmode(mode),"\nbandwidth:\t\t",width
print "ITU_region:\t\t",my_rig.state.itu_region
print "Backend copyright:\t",my_rig.caps.copyright
print "Model:\t\t\t",my_rig.caps.model_name
print "Manufacturer:\t\t",my_rig.caps.mfg_name
print "Backend version:\t",my_rig.caps.version
print "Backend license:\t",my_rig.caps.copyright
print "Rig info:\t\t", my_rig.get_info()
my_rig.set_level ("VOX", 1)
print "VOX level:\t\t",my_rig.get_level_i("VOX")
my_rig.set_level (Hamlib.RIG_LEVEL_VOX, 5)
print "VOX level:\t\t", my_rig.get_level_i(Hamlib.RIG_LEVEL_VOX)
print "strength:\t\t", my_rig.get_level_i(Hamlib.RIG_LEVEL_STRENGTH)
print "status:\t\t\t",my_rig.error_status
print "status(str):\t\t",Hamlib.rigerror(my_rig.error_status)
chan = Hamlib.channel(Hamlib.RIG_VFO_B)
my_rig.get_channel(chan)
print "get_channel status:\t",my_rig.error_status
print "VFO:\t\t\t",Hamlib.rig_strvfo(chan.vfo),", ",chan.freq
print "\nSending Morse, '73'"
my_rig.send_morse(Hamlib.RIG_VFO_A, "73")
my_rig.close ()
print "\nSome static functions:"
err, lon1, lat1 = Hamlib.locator2longlat("IN98XC")
err, lon2, lat2 = Hamlib.locator2longlat("DM33DX")
err, loc1 = Hamlib.longlat2locator(lon1, lat1, 3)
err, loc2 = Hamlib.longlat2locator(lon2, lat2, 3)
print "Loc1:\t\tIN98XC -> %9.4f, %9.4f -> %s" % (lon1, lat1, loc1)
print "Loc2:\t\tDM33DX -> %9.4f, %9.4f -> %s" % (lon2, lat2, loc2)
err, dist, az = Hamlib.qrb(lon1, lat1, lon2, lat2)
longpath = Hamlib.distance_long_path(dist)
print "Distance:\t%.3f km, azimuth %.2f, long path:\t%.3f km" \
% (dist, az, longpath)
# dec2dms expects values from 180 to -180
# sw is 1 when deg is negative (west or south) as 0 cannot be signed
err, deg1, mins1, sec1, sw1 = Hamlib.dec2dms(lon1)
err, deg2, mins2, sec2, sw2 = Hamlib.dec2dms(lat1)
lon3 = Hamlib.dms2dec(deg1, mins1, sec1, sw1)
lat3 = Hamlib.dms2dec(deg2, mins2, sec2, sw2)
print 'Longitude:\t%4.4f, %4d° %2d\' %2d" %1s\trecoded: %9.4f' \
% (lon1, deg1, mins1, sec1, ('W' if sw1 else 'E'), lon3)
print 'Latitude:\t%4.4f, %4d° %2d\' %2d" %1s\trecoded: %9.4f' \
% (lat1, deg2, mins2, sec2, ('S' if sw2 else 'N'), lat3)
def get(self):
Hamlib.rig_set_debug (Hamlib.RIG_DEBUG_NONE)
# Init RIG_MODEL_DUMMY
my_rig = Hamlib.Rig (Hamlib.RIG_MODEL_DUMMY)
my_rig.set_conf ("rig_pathname","/dev/Rig")
my_rig.set_conf ("retry","5")
my_rig.open ()
# 1073741944 is token value for "itu_region"
# but using get_conf is much more convenient
region = my_rig.get_conf(1073741944)
rpath = my_rig.get_conf("rig_pathname")
retry = my_rig.get_conf("retry")
print "status(str):\t\t",Hamlib.rigerror(my_rig.error_status)
print "get_conf:\t\tpath = %s, retry = %s, ITU region = %s" \
% (rpath, retry, region)
my_rig.set_freq (Hamlib.RIG_VFO_B, 5700000000)
my_rig.set_vfo (Hamlib.RIG_VFO_B)
test = "freq:\t\t\t",my_rig.get_freq()
my_rig.set_freq (Hamlib.RIG_VFO_A, 145550000)
#my_rig.set_vfo ("VFOA")
(mode, width) = my_rig.get_mode()
print "mode:\t\t\t",Hamlib.rig_strrmode(mode),"\nbandwidth:\t\t",width
my_rig.set_mode(Hamlib.RIG_MODE_CW)
(mode, width) = my_rig.get_mode()
print "mode:\t\t\t",Hamlib.rig_strrmode(mode),"\nbandwidth:\t\t",width
print "ITU_region:\t\t",my_rig.state.itu_region
print "Backend copyright:\t",my_rig.caps.copyright
print "Model:\t\t\t",my_rig.caps.model_name
print "Manufacturer:\t\t",my_rig.caps.mfg_name
print "Backend version:\t",my_rig.caps.version
print "Backend license:\t",my_rig.caps.copyright
print "Rig info:\t\t", my_rig.get_info()
my_rig.set_level ("VOX", 1)
print "VOX level:\t\t",my_rig.get_level_i("VOX")
my_rig.set_level (Hamlib.RIG_LEVEL_VOX, 5)
print "VOX level:\t\t", my_rig.get_level_i(Hamlib.RIG_LEVEL_VOX)
print "strength:\t\t", my_rig.get_level_i(Hamlib.RIG_LEVEL_STRENGTH)
print "status:\t\t\t",my_rig.error_status
print "status(str):\t\t",Hamlib.rigerror(my_rig.error_status)
chan = Hamlib.channel(Hamlib.RIG_VFO_B)
my_rig.get_channel(chan)
print "get_channel status:\t",my_rig.error_status
print "VFO:\t\t\t",Hamlib.rig_strvfo(chan.vfo),", ",chan.freq
print "\nSending Morse, '73'"
my_rig.send_morse(Hamlib.RIG_VFO_A, "73")
my_rig.close ()
return
