FreeDATA/freedata_server/state_manager.py
2024-05-11 13:30:48 +02:00

261 lines
No EOL
8.9 KiB
Python

import time
import threading
import numpy as np
class StateManager:
def __init__(self, statequeue):
# state related settings
self.statequeue = statequeue
self.newstate = None
self.newradio = None
self.last = time.time()
# freedata_server related states
# not every state is needed to publish, yet
# TODO can we reduce them?
self.channel_busy_slot = [False, False, False, False, False]
self.channel_busy_event = threading.Event()
self.channel_busy_condition_traffic = threading.Event()
self.channel_busy_condition_codec2 = threading.Event()
self.is_modem_running = False
self.is_modem_busy = threading.Event()
self.setARQ(False)
self.is_beacon_running = False
self.is_away_from_key = False
# If true, any wait() call is blocking
self.transmitting_event = threading.Event()
self.setTransmitting(False)
self.audio_dbfs = 0
self.dxcallsign: bytes = b"ZZ9YY-0"
self.dxgrid: bytes = b"------"
self.heard_stations = []
self.activities_list = {}
self.arq_iss_sessions = {}
self.arq_irs_sessions = {}
self.p2p_connection_sessions = {}
#self.mesh_routing_table = []
self.radio_frequency = 0
self.radio_mode = None
self.radio_bandwidth = 0
self.radio_rf_level = 0
self.s_meter_strength = 0
self.radio_tuner = False
self.radio_swr = 0
# Set rig control status regardless or rig control method
self.radio_status = False
def sendState(self):
currentState = self.get_state_event(False)
self.statequeue.put(currentState)
return currentState
def sendStateUpdate(self, state):
self.statequeue.put(state)
def set(self, key, value):
setattr(self, key, value)
#print(f"State ==> Setting {key} to value {value}")
# only process data if changed
new_state = self.get_state_event(True)
if new_state != self.newstate:
self.newstate = new_state
self.sendStateUpdate(new_state)
def set_radio(self, key, value):
setattr(self, key, value)
#print(f"State ==> Setting {key} to value {value}")
# only process data if changed
new_radio = self.get_radio_event(True)
if new_radio != self.newradio:
self.newradio = new_radio
self.sendStateUpdate(new_radio)
def set_channel_slot_busy(self, array):
for i in range(0,len(array),1):
if not array[i] == self.channel_busy_slot[i]:
self.channel_busy_slot = array
self.newstate = self.get_state_event(True)
self.sendStateUpdate(self.newstate)
continue
def get_state_event(self, isChangedState):
msgtype = "state-change"
if (not isChangedState):
msgtype = "state"
return {
"type": msgtype,
"is_modem_running": self.is_modem_running,
"is_beacon_running": self.is_beacon_running,
"is_away_from_key": self.is_away_from_key,
"radio_status": self.radio_status,
"channel_busy_slot": self.channel_busy_slot,
"is_codec2_traffic": self.is_receiving_codec2_signal(),
"audio_dbfs": self.audio_dbfs,
"activities": self.activities_list,
"is_modem_busy" : self.getARQ()
}
def get_radio_event(self, isChangedState):
msgtype = "radio-change"
if (not isChangedState):
msgtype = "radio"
return {
"type": msgtype,
"radio_status": self.radio_status,
"radio_frequency": self.radio_frequency,
"radio_mode": self.radio_mode,
"s_meter_strength": self.s_meter_strength,
"radio_swr" : self.radio_swr,
"radio_tuner": self.radio_tuner,
}
# .wait() blocks until the event is set
def isTransmitting(self):
return not self.transmitting_event.is_set()
# .wait() blocks until the event is set
def setTransmitting(self, transmitting: bool):
if transmitting:
self.transmitting_event.clear()
else:
self.transmitting_event.set()
def setARQ(self, busy):
if busy:
self.is_modem_busy.clear()
else:
self.is_modem_busy.set()
def getARQ(self):
return not self.is_modem_busy.is_set()
def waitForTransmission(self):
self.transmitting_event.wait()
def waitForChannelBusy(self):
self.channel_busy_event.wait(2)
def register_arq_iss_session(self, session):
if session.id in self.arq_iss_sessions:
return False
self.arq_iss_sessions[session.id] = session
return True
def register_arq_irs_session(self, session):
if session.id in self.arq_irs_sessions:
return False
self.arq_irs_sessions[session.id] = session
return True
def check_if_running_arq_session(self, irs=False):
sessions = self.arq_irs_sessions if irs else self.arq_iss_sessions
for session_id in sessions:
# do a session cleanup of outdated sessions before
if sessions[session_id].is_session_outdated():
print(f"session cleanup.....{session_id}")
if irs:
self.remove_arq_irs_session(session_id)
else:
self.remove_arq_iss_session(session_id)
# check again if session id exists in session because of cleanup
if session_id in sessions and sessions[session_id].state.name not in ['ENDED', 'ABORTED', 'FAILED']:
print(f"[State Manager] running session...[{session_id}]")
return True
return False
return False
def get_arq_iss_session(self, id):
if id not in self.arq_iss_sessions:
#raise RuntimeError(f"ARQ ISS Session '{id}' not found!")
# DJ2LS: WIP We need to find a better way of handling this
pass
return self.arq_iss_sessions[id]
def get_arq_irs_session(self, id):
if id not in self.arq_irs_sessions:
#raise RuntimeError(f"ARQ IRS Session '{id}' not found!")
# DJ2LS: WIP We need to find a better way of handling this
pass
return self.arq_irs_sessions[id]
def remove_arq_iss_session(self, id):
if id in self.arq_iss_sessions:
del self.arq_iss_sessions[id]
def remove_arq_irs_session(self, id):
if id in self.arq_irs_sessions:
del self.arq_irs_sessions[id]
def add_activity(self, activity_data):
# Generate a random 8-byte string as hex
activity_id = np.random.bytes(8).hex()
# if timestamp not provided, add it here
if 'timestamp' not in activity_data:
activity_data['timestamp'] = int(time.time())
# if frequency not provided, add it here
if 'frequency' not in activity_data:
activity_data['frequency'] = self.radio_frequency
self.activities_list[activity_id] = activity_data
self.sendStateUpdate(self.newstate)
def calculate_channel_busy_state(self):
if self.channel_busy_condition_traffic.is_set() and self.channel_busy_condition_codec2.is_set():
self.channel_busy_event.set()
else:
self.channel_busy_event = threading.Event()
def set_channel_busy_condition_traffic(self, busy):
if not busy:
self.channel_busy_condition_traffic.set()
else:
self.channel_busy_condition_traffic = threading.Event()
self.calculate_channel_busy_state()
def set_channel_busy_condition_codec2(self, traffic):
if not traffic:
self.channel_busy_condition_codec2.set()
else:
self.channel_busy_condition_codec2 = threading.Event()
self.calculate_channel_busy_state()
def is_receiving_codec2_signal(self):
return not self.channel_busy_condition_codec2.is_set()
def get_radio_status(self):
return {
"radio_status": self.radio_status,
"radio_frequency": self.radio_frequency,
"radio_mode": self.radio_mode,
"radio_rf_level": self.radio_rf_level,
"s_meter_strength": self.s_meter_strength,
"radio_swr": self.radio_swr,
"radio_tuner": self.radio_tuner
}
def register_p2p_connection_session(self, session):
if session.session_id in self.p2p_connection_sessions:
print("session already registered...")
return False
self.p2p_connection_sessions[session.session_id] = session
return True
def get_p2p_connection_session(self, id):
if id not in self.p2p_connection_sessions:
pass
return self.p2p_connection_sessions[id]