316 lines
10 KiB
Python
316 lines
10 KiB
Python
from datetime import datetime, timezone, timedelta
|
|
from owrx.source import SdrSourceEventClient, SdrSourceState, SdrClientClass, SdrBusyState
|
|
from owrx.config import Config
|
|
import threading
|
|
import math
|
|
from abc import ABC, ABCMeta, abstractmethod
|
|
|
|
import logging
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class ScheduleEntry(ABC):
|
|
def __init__(self, startTime, endTime, profile):
|
|
self.startTime = startTime
|
|
self.endTime = endTime
|
|
self.profile = profile
|
|
|
|
def getProfile(self):
|
|
return self.profile
|
|
|
|
def __str__(self):
|
|
return "{0} - {1}: {2}".format(self.startTime, self.endTime, self.profile)
|
|
|
|
@abstractmethod
|
|
def isCurrent(self, dt):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def getScheduledEnd(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def getNextActivation(self):
|
|
pass
|
|
|
|
|
|
class TimeScheduleEntry(ScheduleEntry):
|
|
def isCurrent(self, dt):
|
|
time = dt.time()
|
|
if self.startTime < self.endTime:
|
|
return self.startTime <= time < self.endTime
|
|
else:
|
|
return self.startTime <= time or time < self.endTime
|
|
|
|
def getScheduledEnd(self):
|
|
now = datetime.utcnow()
|
|
end = now.combine(date=now.date(), time=self.endTime)
|
|
while end < now:
|
|
end += timedelta(days=1)
|
|
return end
|
|
|
|
def getNextActivation(self):
|
|
now = datetime.utcnow()
|
|
start = now.combine(date=now.date(), time=self.startTime)
|
|
while start < now:
|
|
start += timedelta(days=1)
|
|
return start
|
|
|
|
|
|
class DatetimeScheduleEntry(ScheduleEntry):
|
|
def isCurrent(self, dt):
|
|
return self.startTime <= dt < self.endTime
|
|
|
|
def getScheduledEnd(self):
|
|
return self.endTime
|
|
|
|
def getNextActivation(self):
|
|
return self.startTime
|
|
|
|
|
|
class Schedule(ABC):
|
|
@staticmethod
|
|
def parse(props):
|
|
if "scheduler" in props:
|
|
sc = props["scheduler"]
|
|
t = sc["type"] if "type" in sc else "static"
|
|
if t == "static":
|
|
return StaticSchedule(sc["schedule"])
|
|
elif t == "daylight":
|
|
return DaylightSchedule(sc["schedule"])
|
|
else:
|
|
logger.warning("Invalid scheduler type: %s", t)
|
|
# downwards compatibility
|
|
elif "schedule" in props:
|
|
return StaticSchedule(props["schedule"])
|
|
|
|
@abstractmethod
|
|
def getCurrentEntry(self):
|
|
pass
|
|
|
|
@abstractmethod
|
|
def getNextEntry(self):
|
|
pass
|
|
|
|
|
|
class TimerangeSchedule(Schedule, metaclass=ABCMeta):
|
|
@abstractmethod
|
|
def getEntries(self):
|
|
pass
|
|
|
|
def getCurrentEntry(self):
|
|
current = [p for p in self.getEntries() if p.isCurrent(datetime.utcnow())]
|
|
if current:
|
|
return current[0]
|
|
return None
|
|
|
|
def getNextEntry(self):
|
|
s = sorted(self.getEntries(), key=lambda e: e.getNextActivation())
|
|
if s:
|
|
return s[0]
|
|
return None
|
|
|
|
|
|
class StaticSchedule(TimerangeSchedule):
|
|
def __init__(self, scheduleDict):
|
|
self.entries = []
|
|
for time, profile in scheduleDict.items():
|
|
if len(time) != 9:
|
|
logger.warning("invalid schedule spec: %s", time)
|
|
continue
|
|
|
|
startTime = datetime.strptime(time[0:4], "%H%M").replace(tzinfo=timezone.utc).time()
|
|
endTime = datetime.strptime(time[5:9], "%H%M").replace(tzinfo=timezone.utc).time()
|
|
self.entries.append(TimeScheduleEntry(startTime, endTime, profile))
|
|
|
|
def getEntries(self):
|
|
return self.entries
|
|
|
|
|
|
class DaylightSchedule(TimerangeSchedule):
|
|
greyLineTime = timedelta(hours=1)
|
|
|
|
def __init__(self, scheduleDict):
|
|
self.schedule = scheduleDict
|
|
|
|
def getSunTimes(self, date):
|
|
pm = Config.get()
|
|
lat = pm["receiver_gps"]["lat"]
|
|
lng = pm["receiver_gps"]["lon"]
|
|
degtorad = math.pi / 180
|
|
radtodeg = 180 / math.pi
|
|
|
|
# Number of days since 01/01
|
|
days = date.timetuple().tm_yday
|
|
|
|
# Longitudinal correction
|
|
longCorr = 4 * lng
|
|
|
|
# calibrate for solstice
|
|
b = 2 * math.pi * (days - 81) / 365
|
|
|
|
# Equation of Time Correction
|
|
eoTCorr = 9.87 * math.sin(2 * b) - 7.53 * math.cos(b) - 1.5 * math.sin(b)
|
|
|
|
# Solar correction
|
|
solarCorr = longCorr + eoTCorr
|
|
|
|
# Solar declination
|
|
declination = math.asin(math.sin(23.45 * degtorad) * math.sin(b))
|
|
|
|
sunrise = 12 - math.acos(-math.tan(lat * degtorad) * math.tan(declination)) * radtodeg / 15 - solarCorr / 60
|
|
sunset = 12 + math.acos(-math.tan(lat * degtorad) * math.tan(declination)) * radtodeg / 15 - solarCorr / 60
|
|
|
|
midnight = datetime.combine(date, datetime.min.time())
|
|
sunrise = midnight + timedelta(hours=sunrise)
|
|
sunset = midnight + timedelta(hours=sunset)
|
|
logger.debug("for {date} sunrise: {sunrise} sunset {sunset}".format(date=date, sunrise=sunrise, sunset=sunset))
|
|
|
|
return sunrise, sunset
|
|
|
|
def getEntries(self):
|
|
now = datetime.utcnow()
|
|
date = now.date()
|
|
# greyline is optional, it its set it will shorten the other profiles
|
|
useGreyline = "greyline" in self.schedule
|
|
entries = []
|
|
|
|
delta = DaylightSchedule.greyLineTime if useGreyline else timedelta()
|
|
events = []
|
|
# we need to start yesterday for longitudes close to the date line
|
|
offset = -1
|
|
while len(events) < 1:
|
|
sunrise, sunset = self.getSunTimes(date + timedelta(days=offset))
|
|
offset += 1
|
|
events += [{"type": "sunrise", "time": sunrise}, {"type": "sunset", "time": sunset}]
|
|
# keep only events in the future
|
|
events = [v for v in events if v["time"] + delta > now]
|
|
events.sort(key=lambda e: e["time"])
|
|
|
|
previousEvent = None
|
|
for event in events:
|
|
# night profile _until_ sunrise, day profile _until_ sunset
|
|
stype = "night" if event["type"] == "sunrise" else "day"
|
|
if stype in self.schedule and (previousEvent is not None or event["time"] - delta > now):
|
|
start = now if previousEvent is None else previousEvent
|
|
entries.append(DatetimeScheduleEntry(start, event["time"] - delta, self.schedule[stype]))
|
|
if useGreyline:
|
|
entries.append(
|
|
DatetimeScheduleEntry(event["time"] - delta, event["time"] + delta, self.schedule["greyline"])
|
|
)
|
|
previousEvent = event["time"] + delta
|
|
|
|
logger.debug([str(e) for e in entries])
|
|
return entries
|
|
|
|
|
|
class ServiceScheduler(SdrSourceEventClient):
|
|
def __init__(self, source):
|
|
self.source = source
|
|
self.selectionTimer = None
|
|
self.currentEntry = None
|
|
self.source.addClient(self)
|
|
self.schedule = None
|
|
props = self.source.getProps()
|
|
self.subscriptions = []
|
|
self.subscriptions.append(props.filter("center_freq", "samp_rate").wire(self.onFrequencyChange))
|
|
self.subscriptions.append(props.wireProperty("scheduler", self.parseSchedule))
|
|
# wireProperty calls parseSchedule with the initial value
|
|
# self.parseSchedule()
|
|
|
|
def parseSchedule(self, *args):
|
|
props = self.source.getProps()
|
|
self.schedule = Schedule.parse(props)
|
|
self.scheduleSelection()
|
|
|
|
def shutdown(self):
|
|
while self.subscriptions:
|
|
self.subscriptions.pop().cancel()
|
|
self.cancelTimer()
|
|
self.source.removeClient(self)
|
|
|
|
def scheduleSelection(self, time=None):
|
|
if not self.source.isEnabled() or self.source.isFailed():
|
|
return
|
|
seconds = 10
|
|
if time is not None:
|
|
delta = time - datetime.utcnow()
|
|
seconds = delta.total_seconds()
|
|
self.cancelTimer()
|
|
self.selectionTimer = threading.Timer(seconds, self.selectProfile)
|
|
self.selectionTimer.start()
|
|
|
|
def cancelTimer(self):
|
|
if self.selectionTimer:
|
|
self.selectionTimer.cancel()
|
|
|
|
def getClientClass(self) -> SdrClientClass:
|
|
if self.currentEntry is None:
|
|
return SdrClientClass.INACTIVE
|
|
else:
|
|
return SdrClientClass.BACKGROUND
|
|
|
|
def onStateChange(self, state: SdrSourceState):
|
|
if state is SdrSourceState.STOPPING:
|
|
self.scheduleSelection()
|
|
|
|
def onFail(self):
|
|
self.shutdown()
|
|
|
|
def onShutdown(self):
|
|
self.shutdown()
|
|
|
|
def onDisable(self):
|
|
self.cancelTimer()
|
|
|
|
def onEnable(self):
|
|
self.scheduleSelection()
|
|
|
|
def onBusyStateChange(self, state: SdrBusyState):
|
|
if state is SdrBusyState.IDLE:
|
|
self.scheduleSelection()
|
|
|
|
def onFrequencyChange(self, changes):
|
|
self.scheduleSelection()
|
|
|
|
def _setCurrentEntry(self, entry):
|
|
self.currentEntry = entry
|
|
|
|
if entry is not None:
|
|
logger.debug("selected profile %s until %s", entry.getProfile(), entry.getScheduledEnd())
|
|
self.scheduleSelection(entry.getScheduledEnd())
|
|
|
|
try:
|
|
self.source.activateProfile(entry.getProfile())
|
|
self.source.start()
|
|
except KeyError:
|
|
pass
|
|
|
|
# tell the source to re-evaluate its current status
|
|
# this should make it shut down if there's no other activity
|
|
# TODO this is an improvised solution, should probably be integrated / improved in SdrSourceEventClient
|
|
self.source.checkStatus()
|
|
|
|
def selectProfile(self):
|
|
if self.source.hasClients(SdrClientClass.USER):
|
|
logger.debug("source has active users; not touching")
|
|
return
|
|
|
|
if self.schedule is None:
|
|
self._setCurrentEntry(None)
|
|
logger.debug("no active schedule, scheduler standing by for external events.")
|
|
return
|
|
|
|
logger.debug("source seems to be idle, selecting profile for background services")
|
|
self._setCurrentEntry(self.schedule.getCurrentEntry())
|
|
|
|
if self.currentEntry is None:
|
|
logger.debug("schedule did not return a current profile. checking next (future) entry...")
|
|
nextEntry = self.schedule.getNextEntry()
|
|
if nextEntry is not None:
|
|
self.scheduleSelection(nextEntry.getNextActivation())
|
|
else:
|
|
logger.debug("no next entry available, scheduler standing by for external events.")
|
|
return
|