openwebrx-clone/owrx/source.py

559 lines
19 KiB
Python
Raw Normal View History

2019-05-04 18:26:11 +00:00
import subprocess
from owrx.config import PropertyManager
from owrx.feature import FeatureDetector, UnknownFeatureException
2019-05-04 18:26:11 +00:00
import threading
import csdr
2019-05-05 15:34:40 +00:00
import time
import os
import signal
import sys
import socket
2019-05-10 19:50:58 +00:00
import logging
logger = logging.getLogger(__name__)
2019-05-04 18:26:11 +00:00
2019-05-09 20:44:29 +00:00
class SdrService(object):
sdrProps = None
sources = {}
lastPort = None
@staticmethod
def getNextPort():
pm = PropertyManager.getSharedInstance()
(start, end) = pm["iq_port_range"]
if SdrService.lastPort is None:
SdrService.lastPort = start
else:
SdrService.lastPort += 1
if SdrService.lastPort > end:
raise IndexError("no more available ports to start more sdrs")
return SdrService.lastPort
@staticmethod
def loadProps():
2019-05-09 20:44:29 +00:00
if SdrService.sdrProps is None:
pm = PropertyManager.getSharedInstance()
featureDetector = FeatureDetector()
2019-05-09 20:44:29 +00:00
def loadIntoPropertyManager(dict: dict):
propertyManager = PropertyManager()
for (name, value) in dict.items():
propertyManager[name] = value
return propertyManager
def sdrTypeAvailable(value):
try:
if not featureDetector.is_available(value["type"]):
2019-05-10 19:50:58 +00:00
logger.error("The RTL source type \"{0}\" is not available. please check requirements.".format(value["type"]))
return False
return True
except UnknownFeatureException:
2019-05-10 19:50:58 +00:00
logger.error("The RTL source type \"{0}\" is invalid. Please check your configuration".format(value["type"]))
return False
# transform all dictionary items into PropertyManager object, filtering out unavailable ones
SdrService.sdrProps = {
name: loadIntoPropertyManager(value) for (name, value) in pm["sdrs"].items() if sdrTypeAvailable(value)
}
2019-05-10 19:50:58 +00:00
logger.info("SDR sources loaded. Availables SDRs: {0}".format(", ".join(map(lambda x: x["name"], SdrService.sdrProps.values()))))
@staticmethod
def getSource(id = None):
SdrService.loadProps()
2019-05-09 20:44:29 +00:00
if id is None:
# TODO: configure default sdr in config? right now it will pick the first one off the list.
id = list(SdrService.sdrProps.keys())[0]
2019-05-10 14:14:16 +00:00
sources = SdrService.getSources()
return sources[id]
@staticmethod
def getSources():
SdrService.loadProps()
for id in SdrService.sdrProps.keys():
if not id in SdrService.sources:
props = SdrService.sdrProps[id]
className = ''.join(x for x in props["type"].title() if x.isalnum()) + "Source"
cls = getattr(sys.modules[__name__], className)
SdrService.sources[id] = cls(props, SdrService.getNextPort())
return SdrService.sources
2019-05-09 20:44:29 +00:00
class SdrSource(object):
def __init__(self, props, port):
self.props = props
2019-05-10 14:14:16 +00:00
self.activateProfile()
2019-05-09 20:44:29 +00:00
self.rtlProps = self.props.collect(
"type", "samp_rate", "nmux_memory", "center_freq", "ppm", "rf_gain", "lna_gain", "rf_amp"
).defaults(PropertyManager.getSharedInstance())
def restart(name, value):
2019-05-10 19:50:58 +00:00
logger.debug("restarting sdr source due to property change: {0} changed to {1}".format(name, value))
self.stop()
self.start()
2019-05-09 20:44:29 +00:00
self.rtlProps.wire(restart)
self.port = port
self.monitor = None
self.clients = []
self.spectrumClients = []
self.spectrumThread = None
2019-05-10 20:08:18 +00:00
self.process = None
self.modificationLock = threading.Lock()
# override these in subclasses as necessary
self.command = None
self.format_conversion = None
2019-05-10 14:14:16 +00:00
def activateProfile(self, id = None):
profiles = self.props["profiles"]
if id is None:
id = list(profiles.keys())[0]
2019-05-10 19:50:58 +00:00
logger.debug("activating profile {0}".format(id))
2019-05-10 14:14:16 +00:00
profile = profiles[id]
for (key, value) in profile.items():
# skip the name, that would overwrite the source name.
if key == "name": continue
self.props[key] = value
def getProfiles(self):
return self.props["profiles"]
def getName(self):
return self.props["name"]
2019-05-09 20:44:29 +00:00
def getProps(self):
return self.props
def getPort(self):
return self.port
def start(self):
self.modificationLock.acquire()
if self.monitor:
self.modificationLock.release()
return
2019-05-09 20:44:29 +00:00
props = self.rtlProps
start_sdr_command = self.command.format(
samp_rate = props["samp_rate"],
center_freq = props["center_freq"],
ppm = props["ppm"],
rf_gain = props["rf_gain"],
lna_gain = props["lna_gain"],
rf_amp = props["rf_amp"]
)
if self.format_conversion is not None:
start_sdr_command += " | " + self.format_conversion
2019-05-04 18:26:11 +00:00
nmux_bufcnt = nmux_bufsize = 0
2019-05-07 14:32:53 +00:00
while nmux_bufsize < props["samp_rate"]/4: nmux_bufsize += 4096
while nmux_bufsize * nmux_bufcnt < props["nmux_memory"] * 1e6: nmux_bufcnt += 1
2019-05-04 18:26:11 +00:00
if nmux_bufcnt == 0 or nmux_bufsize == 0:
2019-05-10 19:50:58 +00:00
logger.error("Error: nmux_bufsize or nmux_bufcnt is zero. These depend on nmux_memory and samp_rate options in config_webrx.py")
self.modificationLock.release()
2019-05-04 18:26:11 +00:00
return
2019-05-10 19:50:58 +00:00
logger.debug("nmux_bufsize = %d, nmux_bufcnt = %d" % (nmux_bufsize, nmux_bufcnt))
2019-05-09 20:44:29 +00:00
cmd = start_sdr_command + " | nmux --bufsize %d --bufcnt %d --port %d --address 127.0.0.1" % (nmux_bufsize, nmux_bufcnt, self.port)
self.process = subprocess.Popen(cmd, shell=True, preexec_fn=os.setpgrp)
2019-05-10 19:50:58 +00:00
logger.info("Started rtl source: " + cmd)
while True:
testsock = socket.socket()
try:
testsock.connect(("127.0.0.1", self.getPort()))
testsock.close()
break
except:
time.sleep(0.1)
def wait_for_process_to_end():
rc = self.process.wait()
2019-05-10 19:50:58 +00:00
logger.debug("shut down with RC={0}".format(rc))
2019-05-09 20:44:29 +00:00
self.monitor = None
self.monitor = threading.Thread(target = wait_for_process_to_end)
self.monitor.start()
self.spectrumThread = SpectrumThread(self)
self.spectrumThread.start()
self.modificationLock.release()
for c in self.clients:
c.onSdrAvailable()
def isAvailable(self):
return self.monitor is not None
def stop(self):
for c in self.clients:
c.onSdrUnavailable()
self.modificationLock.acquire()
2019-05-10 20:08:18 +00:00
if self.spectrumThread is not None:
self.spectrumThread.stop()
2019-05-10 20:08:18 +00:00
if self.process is not None:
try:
os.killpg(os.getpgid(self.process.pid), signal.SIGTERM)
except ProcessLookupError:
# been killed by something else, ignore
pass
if self.monitor:
self.monitor.join()
self.sleepOnRestart()
self.modificationLock.release()
def sleepOnRestart(self):
pass
def addClient(self, c):
self.clients.append(c)
self.start()
def removeClient(self, c):
try:
self.clients.remove(c)
except ValueError:
pass
if not self.clients:
self.stop()
def addSpectrumClient(self, c):
self.spectrumClients.append(c)
def removeSpectrumClient(self, c):
try:
self.spectrumClients.remove(c)
except ValueError:
pass
def writeSpectrumData(self, data):
for c in self.spectrumClients:
c.write_spectrum_data(data)
class RtlSdrSource(SdrSource):
def __init__(self, props, port):
super().__init__(props, port)
self.command = "rtl_sdr -s {samp_rate} -f {center_freq} -p {ppm} -g {rf_gain} -"
self.format_conversion = "csdr convert_u8_f"
class HackrfSource(SdrSource):
def __init__(self, props, port):
super().__init__(props, port)
self.command = "hackrf_transfer -s {samp_rate} -f {center_freq} -g {rf_gain} -l{lna_gain} -a{rf_amp} -r-"
self.format_conversion = "csdr convert_s8_f"
class SdrplaySource(SdrSource):
def __init__(self, props, port):
super().__init__(props, port)
self.command = "rx_sdr -F CF32 -s {samp_rate} -f {center_freq} -p {ppm} -g {rf_gain} -"
self.format_conversion = None
def sleepOnRestart(self):
time.sleep(1)
2019-05-04 18:26:11 +00:00
class SpectrumThread(threading.Thread):
2019-05-09 20:44:29 +00:00
def __init__(self, sdrSource):
self.doRun = True
2019-05-09 20:44:29 +00:00
self.sdrSource = sdrSource
super().__init__()
2019-05-04 18:26:11 +00:00
def run(self):
2019-05-09 20:44:29 +00:00
props = self.sdrSource.props.collect(
"samp_rate", "fft_size", "fft_fps", "fft_voverlap_factor", "fft_compression",
2019-05-09 20:44:29 +00:00
"csdr_dynamic_bufsize", "csdr_print_bufsizes", "csdr_through"
).defaults(PropertyManager.getSharedInstance())
2019-05-07 14:32:53 +00:00
self.dsp = dsp = csdr.dsp()
2019-05-09 20:44:29 +00:00
dsp.nc_port = self.sdrSource.getPort()
2019-05-04 18:26:11 +00:00
dsp.set_demodulator("fft")
props.getProperty("samp_rate").wire(dsp.set_samp_rate)
props.getProperty("fft_size").wire(dsp.set_fft_size)
props.getProperty("fft_fps").wire(dsp.set_fft_fps)
props.getProperty("fft_compression").wire(dsp.set_fft_compression)
def set_fft_averages(key, value):
samp_rate = props["samp_rate"]
fft_size = props["fft_size"]
fft_fps = props["fft_fps"]
fft_voverlap_factor = props["fft_voverlap_factor"]
dsp.set_fft_averages(int(round(1.0 * samp_rate / fft_size / fft_fps / (1.0 - fft_voverlap_factor))) if fft_voverlap_factor>0 else 0)
props.collect("samp_rate", "fft_size", "fft_fps", "fft_voverlap_factor").wire(set_fft_averages)
set_fft_averages(None, None)
2019-05-07 14:32:53 +00:00
dsp.csdr_dynamic_bufsize = props["csdr_dynamic_bufsize"]
dsp.csdr_print_bufsizes = props["csdr_print_bufsizes"]
dsp.csdr_through = props["csdr_through"]
2019-05-10 19:50:58 +00:00
logger.debug("Spectrum thread initialized successfully.")
2019-05-04 18:26:11 +00:00
dsp.start()
2019-05-07 14:32:53 +00:00
if props["csdr_dynamic_bufsize"]:
2019-05-04 18:26:11 +00:00
dsp.read(8) #dummy read to skip bufsize & preamble
2019-05-10 19:50:58 +00:00
logger.debug("Note: CSDR_DYNAMIC_BUFSIZE_ON = 1")
logger.debug("Spectrum thread started.")
2019-05-04 18:26:11 +00:00
bytes_to_read=int(dsp.get_fft_bytes_to_read())
while self.doRun:
data=dsp.read(bytes_to_read)
if len(data) == 0:
time.sleep(1)
else:
self.sdrSource.writeSpectrumData(data)
2019-05-04 18:26:11 +00:00
dsp.stop()
2019-05-10 19:50:58 +00:00
logger.debug("spectrum thread shut down")
2019-05-04 18:26:11 +00:00
self.thread = None
self.sdrSource.removeClient(self)
2019-05-04 18:26:11 +00:00
def stop(self):
2019-05-10 19:50:58 +00:00
logger.debug("stopping spectrum thread")
2019-05-04 21:11:13 +00:00
self.doRun = False
2019-05-05 14:17:55 +00:00
class DspManager(object):
2019-05-09 20:44:29 +00:00
def __init__(self, handler, sdrSource):
self.doRun = False
2019-05-04 21:11:13 +00:00
self.handler = handler
2019-05-09 20:44:29 +00:00
self.sdrSource = sdrSource
self.dsp = None
self.sdrSource.addClient(self)
2019-05-04 21:11:13 +00:00
2019-05-09 20:44:29 +00:00
self.localProps = self.sdrSource.getProps().collect(
"audio_compression", "fft_compression", "digimodes_fft_size", "csdr_dynamic_bufsize",
2019-05-09 20:44:29 +00:00
"csdr_print_bufsizes", "csdr_through", "digimodes_enable", "samp_rate"
).defaults(PropertyManager.getSharedInstance())
2019-05-04 21:11:13 +00:00
self.dsp = csdr.dsp()
#dsp_initialized=False
2019-05-07 14:32:53 +00:00
self.localProps.getProperty("audio_compression").wire(self.dsp.set_audio_compression)
self.localProps.getProperty("fft_compression").wire(self.dsp.set_fft_compression)
2019-05-04 21:11:13 +00:00
self.dsp.set_offset_freq(0)
self.dsp.set_bpf(-4000,4000)
2019-05-07 14:32:53 +00:00
self.localProps.getProperty("digimodes_fft_size").wire(self.dsp.set_secondary_fft_size)
2019-05-05 13:51:33 +00:00
2019-05-09 20:44:29 +00:00
self.dsp.nc_port = self.sdrSource.getPort()
2019-05-07 14:32:53 +00:00
self.dsp.csdr_dynamic_bufsize = self.localProps["csdr_dynamic_bufsize"]
self.dsp.csdr_print_bufsizes = self.localProps["csdr_print_bufsizes"]
self.dsp.csdr_through = self.localProps["csdr_through"]
2019-05-05 13:51:33 +00:00
2019-05-07 14:32:53 +00:00
self.localProps.getProperty("samp_rate").wire(self.dsp.set_samp_rate)
2019-05-05 13:51:33 +00:00
self.localProps.getProperty("output_rate").wire(self.dsp.set_output_rate)
self.localProps.getProperty("offset_freq").wire(self.dsp.set_offset_freq)
self.localProps.getProperty("squelch_level").wire(self.dsp.set_squelch_level)
def set_low_cut(cut):
bpf = self.dsp.get_bpf()
bpf[0] = cut
self.dsp.set_bpf(*bpf)
self.localProps.getProperty("low_cut").wire(set_low_cut)
def set_high_cut(cut):
bpf = self.dsp.get_bpf()
bpf[1] = cut
self.dsp.set_bpf(*bpf)
self.localProps.getProperty("high_cut").wire(set_high_cut)
2019-05-08 14:31:52 +00:00
self.localProps.getProperty("mod").wire(self.dsp.set_demodulator)
2019-05-05 13:51:33 +00:00
2019-05-07 14:32:53 +00:00
if (self.localProps["digimodes_enable"]):
def set_secondary_mod(mod):
if mod == False: mod = None
if self.dsp.get_secondary_demodulator() == mod: return
self.stopSecondaryThreads()
self.dsp.stop()
2019-05-08 14:31:52 +00:00
self.dsp.set_secondary_demodulator(mod)
if mod is not None:
self.handler.write_secondary_dsp_config({
2019-05-07 14:32:53 +00:00
"secondary_fft_size":self.localProps["digimodes_fft_size"],
"if_samp_rate":self.dsp.if_samp_rate(),
"secondary_bw":self.dsp.secondary_bw()
})
self.dsp.start()
if mod:
self.startSecondaryThreads()
self.localProps.getProperty("secondary_mod").wire(set_secondary_mod)
self.localProps.getProperty("secondary_offset_freq").wire(self.dsp.set_secondary_offset_freq)
2019-05-04 21:11:13 +00:00
super().__init__()
2019-05-05 14:17:55 +00:00
def start(self):
self.doRun = self.sdrSource.isAvailable()
if self.doRun:
self.dsp.start()
threading.Thread(target = self.readDspOutput).start()
threading.Thread(target = self.readSMeterOutput).start()
2019-05-05 14:17:55 +00:00
def startSecondaryThreads(self):
self.runSecondary = True
self.secondaryDemodThread = threading.Thread(target = self.readSecondaryDemod)
self.secondaryDemodThread.start()
self.secondaryFftThread = threading.Thread(target = self.readSecondaryFft)
self.secondaryFftThread.start()
def stopSecondaryThreads(self):
self.runSecondary = False
self.secondaryDemodThread = None
self.secondaryFftThread = None
2019-05-05 14:17:55 +00:00
def readDspOutput(self):
2019-05-04 21:11:13 +00:00
while (self.doRun):
data = self.dsp.read(256)
if len(data) != 256:
time.sleep(1)
else:
self.handler.write_dsp_data(data)
2019-05-04 21:11:13 +00:00
2019-05-05 14:17:55 +00:00
def readSMeterOutput(self):
while (self.doRun):
level = self.dsp.get_smeter_level()
self.handler.write_s_meter_level(level)
def readSecondaryDemod(self):
while (self.runSecondary):
data = self.dsp.read_secondary_demod(1)
self.handler.write_secondary_demod(data)
def readSecondaryFft(self):
while (self.runSecondary):
data = self.dsp.read_secondary_fft(int(self.dsp.get_secondary_fft_bytes_to_read()))
self.handler.write_secondary_fft(data)
2019-05-04 21:11:13 +00:00
def stop(self):
self.doRun = False
self.runSecondary = False
2019-05-05 17:46:13 +00:00
self.dsp.stop()
self.sdrSource.removeClient(self)
2019-05-04 21:11:13 +00:00
2019-05-05 13:51:33 +00:00
def setProperty(self, prop, value):
self.localProps.getProperty(prop).setValue(value)
2019-05-05 15:34:40 +00:00
def onSdrAvailable(self):
2019-05-10 22:38:46 +00:00
logger.debug("received onSdrAvailable, attempting DspSource restart")
if not self.doRun:
self.doRun = True
2019-05-10 22:38:46 +00:00
if self.dsp is not None:
self.dsp.start()
threading.Thread(target = self.readDspOutput).start()
threading.Thread(target = self.readSMeterOutput).start()
def onSdrUnavailable(self):
2019-05-10 22:38:46 +00:00
logger.debug("received onSdrUnavailable, shutting down DspSource")
if self.dsp is not None:
self.dsp.stop()
2019-05-05 15:34:40 +00:00
class CpuUsageThread(threading.Thread):
sharedInstance = None
@staticmethod
def getSharedInstance():
if CpuUsageThread.sharedInstance is None:
CpuUsageThread.sharedInstance = CpuUsageThread()
CpuUsageThread.sharedInstance.start()
return CpuUsageThread.sharedInstance
def __init__(self):
self.clients = []
self.doRun = True
self.last_worktime = 0
self.last_idletime = 0
super().__init__()
def run(self):
while self.doRun:
try:
cpu_usage = self.get_cpu_usage()
except:
cpu_usage = 0
for c in self.clients:
c.write_cpu_usage(cpu_usage)
2019-05-10 20:47:40 +00:00
time.sleep(3)
2019-05-10 19:50:58 +00:00
logger.debug("cpu usage thread shut down")
2019-05-12 16:10:24 +00:00
if CpuUsageThread.sharedInstance == self:
CpuUsageThread.sharedInstance = None
2019-05-05 15:34:40 +00:00
def get_cpu_usage(self):
try:
f = open("/proc/stat","r")
except:
return 0 #Workaround, possibly we're on a Mac
line = ""
while not "cpu " in line: line=f.readline()
f.close()
spl = line.split(" ")
worktime = int(spl[2]) + int(spl[3]) + int(spl[4])
idletime = int(spl[5])
dworktime = (worktime - self.last_worktime)
didletime = (idletime - self.last_idletime)
rate = float(dworktime) / (didletime+dworktime)
self.last_worktime = worktime
self.last_idletime = idletime
if (self.last_worktime==0): return 0
return rate
def add_client(self, c):
self.clients.append(c)
def remove_client(self, c):
2019-05-09 20:44:29 +00:00
try:
self.clients.remove(c)
except ValueError:
pass
2019-05-05 15:34:40 +00:00
if not self.clients:
self.shutdown()
def shutdown(self):
2019-05-12 16:10:24 +00:00
self.doRun = False
class ClientReportingThread(threading.Thread):
def __init__(self, registry):
self.doRun = True
self.registry = registry
super().__init__()
def run(self):
while self.doRun:
self.registry.broadcast()
time.sleep(3)
def stop(self):
self.doRun = False
2019-05-10 20:47:40 +00:00
class TooManyClientsException(Exception):
pass
2019-05-12 16:10:24 +00:00
class ClientRegistry(object):
2019-05-10 20:47:40 +00:00
sharedInstance = None
@staticmethod
def getSharedInstance():
2019-05-12 16:10:24 +00:00
if ClientRegistry.sharedInstance is None:
ClientRegistry.sharedInstance = ClientRegistry()
return ClientRegistry.sharedInstance
2019-05-10 20:47:40 +00:00
def __init__(self):
self.clients = []
2019-05-12 16:10:24 +00:00
self.reporter = None
2019-05-10 20:47:40 +00:00
super().__init__()
2019-05-12 16:10:24 +00:00
def broadcast(self):
n = self.clientCount()
for c in self.clients:
c.write_clients(n)
2019-05-10 20:47:40 +00:00
def addClient(self, client):
pm = PropertyManager.getSharedInstance()
if len(self.clients) >= pm["max_clients"]:
raise TooManyClientsException()
self.clients.append(client)
2019-05-12 16:10:24 +00:00
if self.reporter is None:
self.reporter = ClientReportingThread(self)
self.reporter.start()
2019-05-10 20:47:40 +00:00
2019-05-10 21:00:18 +00:00
def clientCount(self):
return len(self.clients)
2019-05-10 20:47:40 +00:00
def removeClient(self, client):
try:
self.clients.remove(client)
except ValueError:
pass
2019-05-12 16:10:24 +00:00
if not self.clients and self.reporter is not None:
self.reporter.stop()
self.reporter = None