Crash_Override/FreeDATA
1
0
Fork 0
mirror of https://github.com/DJ2LS/FreeDATA synced 2024-05-14 08:04:33 +00:00
Code Issues Projects Releases Packages Wiki Activity

some more reducing of globals..

Browse source
This commit is contained in:
DJ2LS 2023-11-13 20:26:27 +01:00
parent 5f8192d5cf
commit fa73706af5
2 changed files with 75 additions and 65 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

137
modem/data_handler.py
View file

@ -23,7 +23,7 @@ import codec2
import helpers import helpers
import modem import modem
import numpy as np import numpy as np
from global_instances import ARQ, Beacon, HamlibParam, ModemParam, Station, Modem from global_instances import ARQ, HamlibParam, ModemParam, Station, Modem
import structlog import structlog
import stats import stats
import ujson as json import ujson as json
@ -48,6 +48,7 @@ class DATA:
self.mycallsign = config['STATION']['mycall'] self.mycallsign = config['STATION']['mycall']
self.mygrid = config['STATION']['mygrid'] self.mygrid = config['STATION']['mygrid']
self.dxcallsign = Station.dxcallsign self.dxcallsign = Station.dxcallsign
self.data_queue_transmit = DATA_QUEUE_TRANSMIT self.data_queue_transmit = DATA_QUEUE_TRANSMIT
@ -115,9 +116,14 @@ class DATA:
# Flag to indicate if we received a low bandwidth mode channel opener # Flag to indicate if we received a low bandwidth mode channel opener
self.received_LOW_BANDWIDTH_MODE = False self.received_LOW_BANDWIDTH_MODE = False
# flag to indicate if modem running in low bandwidth mode
self.low_bandwidth_mode = self.config["MODEM"]["enable_low_bandwidth_mode"]
self.data_channel_max_retries = 15 self.data_channel_max_retries = 15
# event for checking arq_state_event
self.arq_state_event = threading.Event()
# -------------- AVAILABLE MODES START----------- # -------------- AVAILABLE MODES START-----------
# IMPORTANT: LISTS MUST BE OF EQUAL LENGTH # IMPORTANT: LISTS MUST BE OF EQUAL LENGTH
@ -151,7 +157,7 @@ class DATA:
# Mode list for selecting between low bandwidth ( 500Hz ) and modes with higher bandwidth # Mode list for selecting between low bandwidth ( 500Hz ) and modes with higher bandwidth
# but ability to fall back to low bandwidth modes if needed. # but ability to fall back to low bandwidth modes if needed.
if Modem.low_bandwidth_mode: if self.low_bandwidth_mode:
# List of codec2 modes to use in "low bandwidth" mode. # List of codec2 modes to use in "low bandwidth" mode.
self.mode_list = self.mode_list_low_bw self.mode_list = self.mode_list_low_bw
# list of times to wait for corresponding mode in seconds # list of times to wait for corresponding mode in seconds
@ -270,6 +276,7 @@ class DATA:
self.beacon_interval = 0 self.beacon_interval = 0
self.beacon_interval_timer = 0 self.beacon_interval_timer = 0
self.beacon_paused = False
self.beacon_thread = threading.Thread( self.beacon_thread = threading.Thread(
target=self.run_beacon, name="watchdog", daemon=True target=self.run_beacon, name="watchdog", daemon=True
) )
@ -286,10 +293,10 @@ class DATA:
# stuck in IRS # stuck in IRS
# #
# send transmission queued information once # send transmission queued information once
if ARQ.arq_state or ModemParam.is_codec2_traffic: if self.states.is_arq_state or self.states.is_codec2_traffic:
self.log.debug( self.log.debug(
"[Modem] TX DISPATCHER - waiting with processing command ", "[Modem] TX DISPATCHER - waiting with processing command ",
arq_state=ARQ.arq_state, is_arq_state=self.states.is_arq_state,
) )
self.send_data_to_socket_queue( self.send_data_to_socket_queue(
@ -299,7 +306,7 @@ class DATA:
) )
# now stay in while loop until state released # now stay in while loop until state released
while ARQ.arq_state or ModemParam.is_codec2_traffic: while self.states.is_arq_state or self.states.is_codec2_traffic:
threading.Event().wait(0.01) threading.Event().wait(0.01)
# and finally sleep some time # and finally sleep some time
@ -678,15 +685,15 @@ class DATA:
data_in = bytes(data_in) data_in = bytes(data_in)
# only process data if we are in ARQ and BUSY state else return to quit # only process data if we are in ARQ and BUSY state else return to quit
if not ARQ.arq_state and Modem.modem_state not in ["BUSY"]: if not self.states.is_arq_state and Modem.modem_state not in ["BUSY"]:
self.log.warning("[Modem] wrong modem state - dropping data", arq_state=ARQ.arq_state, self.log.warning("[Modem] wrong modem state - dropping data", is_arq_state=self.states.is_arq_state,
modem_state=Modem.modem_state) modem_state=Modem.modem_state)
return return
self.arq_file_transfer = True self.arq_file_transfer = True
Modem.modem_state = "BUSY" Modem.modem_state = "BUSY"
ARQ.arq_state = True self.states.set("is_arq_state", True)
# Update data_channel timestamp # Update data_channel timestamp
self.data_channel_last_received = int(time.time()) self.data_channel_last_received = int(time.time())
@ -1254,7 +1261,7 @@ class DATA:
bufferposition_burst_start = 0 bufferposition_burst_start = 0
# Iterate through data_out buffer # Iterate through data_out buffer
while not self.data_frame_ack_received and ARQ.arq_state: while not self.data_frame_ack_received and self.states.is_arq_state:
# we have self.tx_n_max_retries_per_burst attempts for sending a burst # we have self.tx_n_max_retries_per_burst attempts for sending a burst
for self.tx_n_retry_of_burst in range(self.tx_n_max_retries_per_burst): for self.tx_n_retry_of_burst in range(self.tx_n_max_retries_per_burst):
# Bound speed level to: # Bound speed level to:
@ -1351,7 +1358,7 @@ class DATA:
# After transmission finished, wait for an ACK or RPT frame # After transmission finished, wait for an ACK or RPT frame
while ( while (
ARQ.arq_state self.states.is_arq_state
and not self.burst_ack and not self.burst_ack
and not self.burst_nack and not self.burst_nack
and not self.rpt_request_received and not self.rpt_request_received
@ -1391,8 +1398,8 @@ class DATA:
# We need this part for leaving the repeat loop # We need this part for leaving the repeat loop
# ARQ.arq_state == "DATA" --> when stopping transmission manually # self.states.is_arq_state == "DATA" --> when stopping transmission manually
if not ARQ.arq_state: if not self.states.is_arq_state:
self.log.debug( self.log.debug(
"[Modem] arq_transmit: ARQ State changed to FALSE. Breaking retry loop." "[Modem] arq_transmit: ARQ State changed to FALSE. Breaking retry loop."
) )
@ -1520,7 +1527,7 @@ class DATA:
""" """
# Process data only if we are in ARQ and BUSY state # Process data only if we are in ARQ and BUSY state
if ARQ.arq_state: if self.states.is_arq_state:
Station.dxgrid = b'------' Station.dxgrid = b'------'
helpers.add_to_heard_stations( helpers.add_to_heard_stations(
self.dxcallsign, self.dxcallsign,
@ -1575,7 +1582,7 @@ class DATA:
) -> None: ) -> None:
"""Received an ACK for a transmitted frame""" """Received an ACK for a transmitted frame"""
# Process data only if we are in ARQ and BUSY state # Process data only if we are in ARQ and BUSY state
if ARQ.arq_state: if self.states.is_arq_state:
Station.dxgrid = b'------' Station.dxgrid = b'------'
helpers.add_to_heard_stations( helpers.add_to_heard_stations(
Station.dxcallsign, Station.dxcallsign,
@ -1651,7 +1658,7 @@ class DATA:
""" """
# Only process data if we are in ARQ and BUSY state # Only process data if we are in ARQ and BUSY state
if not ARQ.arq_state or Modem.modem_state != "BUSY": if not self.states.is_arq_state or Modem.modem_state != "BUSY":
return return
Station.dxgrid = b'------' Station.dxgrid = b'------'
helpers.add_to_heard_stations( helpers.add_to_heard_stations(
@ -1715,7 +1722,7 @@ class DATA:
+ "]>> <<[" + "]>> <<["
+ str(self.dxcallsign, "UTF-8") + str(self.dxcallsign, "UTF-8")
+ "]", + "]",
state=ARQ.arq_session_state, self.states.arq_session_state,
) )
# wait if we have a channel busy condition # wait if we have a channel busy condition
@ -1727,7 +1734,7 @@ class DATA:
# wait until data channel is open # wait until data channel is open
while not ARQ.arq_session and not self.arq_session_timeout: while not ARQ.arq_session and not self.arq_session_timeout:
threading.Event().wait(0.01) threading.Event().wait(0.01)
ARQ.arq_session_state = "connecting" self.states.set("arq_session_state", "connecting")
self.send_data_to_socket_queue( self.send_data_to_socket_queue(
freedata="modem-message", freedata="modem-message",
arq="session", arq="session",
@ -1735,8 +1742,8 @@ class DATA:
mycallsign=str(self.mycallsign, 'UTF-8'), mycallsign=str(self.mycallsign, 'UTF-8'),
dxcallsign=str(self.dxcallsign, 'UTF-8'), dxcallsign=str(self.dxcallsign, 'UTF-8'),
) )
if ARQ.arq_session and ARQ.arq_session_state == "connected": if ARQ.arq_session and self.states.arq_session_state == "connected":
# ARQ.arq_session_state = "connected" # self.states.set("arq_session_state", "connected")
self.send_data_to_socket_queue( self.send_data_to_socket_queue(
freedata="modem-message", freedata="modem-message",
arq="session", arq="session",
@ -1754,9 +1761,9 @@ class DATA:
+ "]", + "]",
attempts=self.session_connect_max_retries, # Adjust for 0-based for user display attempts=self.session_connect_max_retries, # Adjust for 0-based for user display
reason="maximum connection attempts reached", reason="maximum connection attempts reached",
state=ARQ.arq_session_state, state=self.states.arq_session_state,
) )
ARQ.arq_session_state = "failed" self.states.set("arq_session_state", "failed")
self.send_data_to_socket_queue( self.send_data_to_socket_queue(
freedata="modem-message", freedata="modem-message",
arq="session", arq="session",
@ -1776,7 +1783,7 @@ class DATA:
False if the session open request failed False if the session open request failed
""" """
self.IS_ARQ_SESSION_MASTER = True self.IS_ARQ_SESSION_MASTER = True
ARQ.arq_session_state = "connecting" self.states.set("arq_session_state", "connecting")
# create a random session id # create a random session id
self.session_id = np.random.bytes(1) self.session_id = np.random.bytes(1)
@ -1798,7 +1805,7 @@ class DATA:
+ str(self.dxcallsign, "UTF-8") + str(self.dxcallsign, "UTF-8")
+ "]", + "]",
a=f"{str(attempt + 1)}/{str(self.session_connect_max_retries)}", a=f"{str(attempt + 1)}/{str(self.session_connect_max_retries)}",
state=ARQ.arq_session_state, state=self.states.arq_session_state,
) )
self.send_data_to_socket_queue( self.send_data_to_socket_queue(
@ -1823,7 +1830,7 @@ class DATA:
return True return True
# Stop waiting and interrupt if data channel is getting closed while opening # Stop waiting and interrupt if data channel is getting closed while opening
if ARQ.arq_session_state == "disconnecting": if self.states.arq_session_state == "disconnecting":
# disabled this session close as its called twice # disabled this session close as its called twice
# self.close_session() # self.close_session()
return False return False
@ -1865,7 +1872,7 @@ class DATA:
return False return False
self.IS_ARQ_SESSION_MASTER = False self.IS_ARQ_SESSION_MASTER = False
ARQ.arq_session_state = "connecting" self.states.set("arq_session_state", "connecting")
# Update arq_session timestamp # Update arq_session timestamp
self.arq_session_last_received = int(time.time()) self.arq_session_last_received = int(time.time())
@ -1893,7 +1900,7 @@ class DATA:
+ "]>>|<<[" + "]>>|<<["
+ str(self.dxcallsign, "UTF-8") + str(self.dxcallsign, "UTF-8")
+ "]", + "]",
state=ARQ.arq_session_state, self.states.arq_session_state,
) )
ARQ.arq_session = True ARQ.arq_session = True
Modem.modem_state = "BUSY" Modem.modem_state = "BUSY"
@ -1909,7 +1916,7 @@ class DATA:
def close_session(self) -> None: def close_session(self) -> None:
"""Close the ARQ session""" """Close the ARQ session"""
ARQ.arq_session_state = "disconnecting" self.states.set("arq_session_state", "disconnecting")
self.log.info( self.log.info(
"[Modem] SESSION [" "[Modem] SESSION ["
@ -1917,7 +1924,7 @@ class DATA:
+ "]<<X>>[" + "]<<X>>["
+ str(self.dxcallsign, "UTF-8") + str(self.dxcallsign, "UTF-8")
+ "]", + "]",
state=ARQ.arq_session_state, self.states.arq_session_state,
) )
self.send_data_to_socket_queue( self.send_data_to_socket_queue(
@ -1954,8 +1961,8 @@ class DATA:
# Close the session if the CRC matches the remote station in static. # Close the session if the CRC matches the remote station in static.
_valid_crc, mycallsign = helpers.check_callsign(self.mycallsign, bytes(data_in[2:5])) _valid_crc, mycallsign = helpers.check_callsign(self.mycallsign, bytes(data_in[2:5]))
_valid_session = helpers.check_session_id(self.session_id, bytes(data_in[1:2])) _valid_session = helpers.check_session_id(self.session_id, bytes(data_in[1:2]))
if (_valid_crc or _valid_session) and ARQ.arq_session_state not in ["disconnected"]: if (_valid_crc or _valid_session) and self.states.arq_session_state not in ["disconnected"]:
ARQ.arq_session_state = "disconnected" self.states.set("arq_session_state", "disconnected")
Station.dxgrid = b'------' Station.dxgrid = b'------'
helpers.add_to_heard_stations( helpers.add_to_heard_stations(
Station.dxcallsign, Station.dxcallsign,
@ -1971,7 +1978,7 @@ class DATA:
+ "]<<X>>[" + "]<<X>>["
+ str(self.dxcallsign, "UTF-8") + str(self.dxcallsign, "UTF-8")
+ "]", + "]",
state=ARQ.arq_session_state, self.states.arq_session_state,
) )
self.send_data_to_socket_queue( self.send_data_to_socket_queue(
@ -1990,7 +1997,7 @@ class DATA:
"""Send ARQ sesion heartbeat while connected""" """Send ARQ sesion heartbeat while connected"""
# ARQ.arq_session = True # ARQ.arq_session = True
# Modem.modem_state = "BUSY" # Modem.modem_state = "BUSY"
# ARQ.arq_session_state = "connected" # self.states.set("arq_session_state", "connected")
connection_frame = bytearray(self.length_sig0_frame) connection_frame = bytearray(self.length_sig0_frame)
connection_frame[:1] = bytes([FR_TYPE.ARQ_SESSION_HB.value]) connection_frame[:1] = bytes([FR_TYPE.ARQ_SESSION_HB.value])
@ -2017,7 +2024,7 @@ class DATA:
# Accept session data if the DXCALLSIGN_CRC matches the station in static or session id. # Accept session data if the DXCALLSIGN_CRC matches the station in static or session id.
_valid_crc, _ = helpers.check_callsign(self.dxcallsign, bytes(data_in[4:7])) _valid_crc, _ = helpers.check_callsign(self.dxcallsign, bytes(data_in[4:7]))
_valid_session = helpers.check_session_id(self.session_id, bytes(data_in[1:2])) _valid_session = helpers.check_session_id(self.session_id, bytes(data_in[1:2]))
if _valid_crc or _valid_session and ARQ.arq_session_state in ["connected", "connecting"]: if _valid_crc or _valid_session and self.states.arq_session_state in ["connected", "connecting"]:
self.log.debug("[Modem] Received session heartbeat") self.log.debug("[Modem] Received session heartbeat")
Station.dxgrid = b'------' Station.dxgrid = b'------'
helpers.add_to_heard_stations( helpers.add_to_heard_stations(
@ -2039,7 +2046,7 @@ class DATA:
) )
ARQ.arq_session = True ARQ.arq_session = True
ARQ.arq_session_state = "connected" self.states.set("arq_session_state", "connected")
Modem.modem_state = "BUSY" Modem.modem_state = "BUSY"
# Update the timeout timestamps # Update the timeout timestamps
@ -2054,9 +2061,9 @@ class DATA:
if ( if (
not self.IS_ARQ_SESSION_MASTER not self.IS_ARQ_SESSION_MASTER
and not self.arq_file_transfer and not self.arq_file_transfer
and ARQ.arq_session_state != 'disconnecting' and self.states.arq_session_state != 'disconnecting'
and ARQ.arq_session_state != 'disconnected' and self.states.arq_session_state != 'disconnected'
and ARQ.arq_session_state != 'failed' and self.states.arq_session_state != 'failed'
): ):
self.transmit_session_heartbeat() self.transmit_session_heartbeat()
@ -2106,13 +2113,13 @@ class DATA:
threading.Event().wait(2.5) threading.Event().wait(2.5)
# init arq state event # init arq state event
ARQ.arq_state_event = threading.Event() self.arq_state_event = threading.Event()
# finally start the channel opening procedure # finally start the channel opening procedure
self.arq_open_data_channel(mycallsign) self.arq_open_data_channel(mycallsign)
# if data channel is open, return true else false # if data channel is open, return true else false
if ARQ.arq_state_event.is_set(): if self.states.is_arq_state_event.is_set():
# start arq transmission # start arq transmission
self.arq_transmit(data_out, hmac_salt) self.arq_transmit(data_out, hmac_salt)
return True return True
@ -2178,7 +2185,7 @@ class DATA:
# check if the Modem is running in low bandwidth mode # check if the Modem is running in low bandwidth mode
# then set the corresponding frametype and build frame # then set the corresponding frametype and build frame
if Modem.low_bandwidth_mode: if self.low_bandwidth_mode:
frametype = bytes([FR_TYPE.ARQ_DC_OPEN_N.value]) frametype = bytes([FR_TYPE.ARQ_DC_OPEN_N.value])
self.log.debug("[Modem] Requesting low bandwidth mode") self.log.debug("[Modem] Requesting low bandwidth mode")
else: else:
@ -2213,19 +2220,19 @@ class DATA:
) )
# Let's check if we have a busy channel and if we are not in a running arq session. # Let's check if we have a busy channel and if we are not in a running arq session.
if ModemParam.channel_busy and not ARQ.arq_state_event.is_set() or ModemParam.is_codec2_traffic: if ModemParam.channel_busy and not self.arq_state_event.is_set() or self.states.is_codec2_traffic:
self.channel_busy_handler() self.channel_busy_handler()
# if channel free, enqueue frame for tx # if channel free, enqueue frame for tx
if not ARQ.arq_state_event.is_set(): if not self.states.is_arq_state_event.is_set():
self.enqueue_frame_for_tx([connection_frame], c2_mode=FREEDV_MODE.sig0.value, copies=1, repeat_delay=0) self.enqueue_frame_for_tx([connection_frame], c2_mode=FREEDV_MODE.sig0.value, copies=1, repeat_delay=0)
# wait until timeout or event set # wait until timeout or event set
random_wait_time = randrange(int(self.duration_sig1_frame * 10), int(self.datachannel_opening_interval * 10), 1) / 10 random_wait_time = randrange(int(self.duration_sig1_frame * 10), int(self.datachannel_opening_interval * 10), 1) / 10
ARQ.arq_state_event.wait(timeout=random_wait_time) self.arq_state_event.wait(timeout=random_wait_time)
if ARQ.arq_state_event.is_set(): if self.states.is_arq_state_event.is_set():
return True return True
if Modem.modem_state in ["IDLE"]: if Modem.modem_state in ["IDLE"]:
return False return False
@ -2263,7 +2270,7 @@ class DATA:
# Station B already tries connecting to Station A. # Station B already tries connecting to Station A.
# For avoiding ignoring repeated connect request in case of packet loss # For avoiding ignoring repeated connect request in case of packet loss
# we are only ignoring packets in case we are ISS # we are only ignoring packets in case we are ISS
if ARQ.arq_state_event.is_set() and not self.is_IRS: if self.states.is_arq_state_event.is_set() and not self.is_IRS:
return False return False
self.is_IRS = True self.is_IRS = True
@ -2289,7 +2296,7 @@ class DATA:
# ISS(n) <-> IRS(w) # ISS(n) <-> IRS(w)
# ISS(n) <-> IRS(n) # ISS(n) <-> IRS(n)
if frametype == FR_TYPE.ARQ_DC_OPEN_W.value and not Modem.low_bandwidth_mode: if frametype == FR_TYPE.ARQ_DC_OPEN_W.value and not self.low_bandwidth_mode:
# ISS(w) <-> IRS(w) # ISS(w) <-> IRS(w)
constellation = "ISS(w) <-> IRS(w)" constellation = "ISS(w) <-> IRS(w)"
self.received_LOW_BANDWIDTH_MODE = False self.received_LOW_BANDWIDTH_MODE = False
@ -2303,7 +2310,7 @@ class DATA:
self.mode_list = self.mode_list_low_bw self.mode_list = self.mode_list_low_bw
self.time_list = self.time_list_low_bw self.time_list = self.time_list_low_bw
self.snr_list = self.snr_list_low_bw self.snr_list = self.snr_list_low_bw
elif frametype == FR_TYPE.ARQ_DC_OPEN_N.value and not Modem.low_bandwidth_mode: elif frametype == FR_TYPE.ARQ_DC_OPEN_N.value and not self.low_bandwidth_mode:
# ISS(n) <-> IRS(w) # ISS(n) <-> IRS(w)
constellation = "ISS(n) <-> IRS(w)" constellation = "ISS(n) <-> IRS(w)"
self.received_LOW_BANDWIDTH_MODE = True self.received_LOW_BANDWIDTH_MODE = True
@ -2370,13 +2377,13 @@ class DATA:
# Set ARQ State AFTER resetting timeouts # Set ARQ State AFTER resetting timeouts
# this avoids timeouts starting too early # this avoids timeouts starting too early
ARQ.arq_state = True self.states.set("is_arq_state", True)
Modem.modem_state = "BUSY" Modem.modem_state = "BUSY"
self.reset_statistics() self.reset_statistics()
# Select the frame type based on the current Modem mode # Select the frame type based on the current Modem mode
if Modem.low_bandwidth_mode or self.received_LOW_BANDWIDTH_MODE: if self.low_bandwidth_mode or self.received_LOW_BANDWIDTH_MODE:
frametype = bytes([FR_TYPE.ARQ_DC_OPEN_ACK_N.value]) frametype = bytes([FR_TYPE.ARQ_DC_OPEN_ACK_N.value])
self.log.debug("[Modem] Responding with low bandwidth mode") self.log.debug("[Modem] Responding with low bandwidth mode")
else: else:
@ -2473,9 +2480,9 @@ class DATA:
) )
# as soon as we set ARQ_STATE to True, transmission starts # as soon as we set ARQ_STATE to True, transmission starts
ARQ.arq_state = True self.states.set("is_arq_state", True)
# also set the ARQ event # also set the ARQ event
ARQ.arq_state_event.set() self.arq_state_event.set()
# Update data_channel timestamp # Update data_channel timestamp
self.data_channel_last_received = int(time.time()) self.data_channel_last_received = int(time.time())
@ -2711,7 +2718,7 @@ class DATA:
""" """
self.log.warning("[Modem] Stopping transmission!") self.log.warning("[Modem] Stopping transmission!")
Modem.modem_state = "IDLE" Modem.modem_state = "IDLE"
ARQ.arq_state = False self.states.set("is_arq_state", False)
self.send_data_to_socket_queue( self.send_data_to_socket_queue(
freedata="modem-message", freedata="modem-message",
arq="transmission", arq="transmission",
@ -2740,10 +2747,10 @@ class DATA:
if ( if (
not ARQ.arq_session not ARQ.arq_session
and not self.arq_file_transfer and not self.arq_file_transfer
and not Beacon.beacon_pause and not self.beacon_paused
#and not ModemParam.channel_busy #and not ModemParam.channel_busy
and Modem.modem_state not in ["BUSY"] and Modem.modem_state not in ["BUSY"]
and not ARQ.arq_state and not self.states.is_arq_state
): ):
self.send_data_to_socket_queue( self.send_data_to_socket_queue(
freedata="modem-message", freedata="modem-message",
@ -2776,7 +2783,7 @@ class DATA:
while ( while (
time.time() < self.beacon_interval_timer time.time() < self.beacon_interval_timer
and self.states.is_beacon_running and self.states.is_beacon_running
and not Beacon.beacon_pause and not self.beacon_paused
): ):
threading.Event().wait(0.01) threading.Event().wait(0.01)
@ -3197,13 +3204,13 @@ class DATA:
self.mycallsign = self.mycallsign self.mycallsign = self.mycallsign
self.session_id = bytes(1) self.session_id = bytes(1)
ARQ.arq_session_state = "disconnected" self.states.set("arq_session_state", "disconnected")
ARQ.speed_list = [] ARQ.speed_list = []
ARQ.arq_state = False self.states.set("is_arq_state", False)
ARQ.arq_state_event = threading.Event() self.arq_state_event = threading.Event()
self.arq_file_transfer = False self.arq_file_transfer = False
Beacon.beacon_pause = False self.beacon_paused = False
# reset beacon interval timer for not directly starting beacon after ARQ # reset beacon interval timer for not directly starting beacon after ARQ
self.beacon_interval_timer = time.time() + self.beacon_interval self.beacon_interval_timer = time.time() + self.beacon_interval
@ -3288,8 +3295,8 @@ class DATA:
# TODO We need to redesign this part for cleaner state handling # TODO We need to redesign this part for cleaner state handling
# Return if not ARQ STATE and not ARQ SESSION STATE as they are different use cases # Return if not ARQ STATE and not ARQ SESSION STATE as they are different use cases
if ( if (
not ARQ.arq_state not self.states.is_arq_state
and ARQ.arq_session_state != "connected" and self.states.arq_session_state != "connected"
or not self.is_IRS or not self.is_IRS
): ):
return return
@ -3333,7 +3340,7 @@ class DATA:
waiting_time = (self.time_list[self.speed_level] * frames_left) + self.duration_sig0_frame + self.channel_busy_timeout + 1 waiting_time = (self.time_list[self.speed_level] * frames_left) + self.duration_sig0_frame + self.channel_busy_timeout + 1
timeout_percent = 100 - (time_left / waiting_time * 100) timeout_percent = 100 - (time_left / waiting_time * 100)
#timeout_percent = 0 #timeout_percent = 0
if timeout_percent >= 75 and not ModemParam.is_codec2_traffic and not Modem.transmitting: if timeout_percent >= 75 and not self.states.is_codec2_traffic and not Modem.transmitting:
override = True override = True
else: else:
override = False override = False
@ -3344,7 +3351,7 @@ class DATA:
# better wait some more time because data might be important for us # better wait some more time because data might be important for us
# reason for this situation can be delays on IRS and ISS, maybe because both had a busy channel condition. # reason for this situation can be delays on IRS and ISS, maybe because both had a busy channel condition.
# Nevertheless, we need to keep timeouts short for efficiency # Nevertheless, we need to keep timeouts short for efficiency
if timeout <= time.time() or modem_error_state and not ModemParam.is_codec2_traffic and not Modem.transmitting or override: if timeout <= time.time() or modem_error_state and not self.states.is_codec2_traffic and not Modem.transmitting or override:
self.log.warning( self.log.warning(
"[Modem] Burst decoding error or timeout", "[Modem] Burst decoding error or timeout",
attempt=self.n_retries_per_burst, attempt=self.n_retries_per_burst,
@ -3406,7 +3413,7 @@ class DATA:
DATA CHANNEL DATA CHANNEL
""" """
# and not static.ARQ_SEND_KEEP_ALIVE: # and not static.ARQ_SEND_KEEP_ALIVE:
if ARQ.arq_state and Modem.modem_state == "BUSY": if self.states.is_arq_state and Modem.modem_state == "BUSY":
threading.Event().wait(0.01) threading.Event().wait(0.01)
if ( if (
self.data_channel_last_received + self.transmission_timeout self.data_channel_last_received + self.transmission_timeout
@ -3484,7 +3491,7 @@ class DATA:
if ( if (
ARQ.arq_session ARQ.arq_session
and self.IS_ARQ_SESSION_MASTER and self.IS_ARQ_SESSION_MASTER
and ARQ.arq_session_state == "connected" and self.states.arq_session_state == "connected"
# and not self.arq_file_transfer # and not self.arq_file_transfer
): ):
threading.Event().wait(1) threading.Event().wait(1)

3
modem/state_manager.py
View file

@ -9,6 +9,9 @@ class STATES:
self.is_codec2_traffic = False self.is_codec2_traffic = False
self.is_modem_running = False self.is_modem_running = False
self.is_beacon_running = False self.is_beacon_running = False
self.is_arq_state = False
self.is_arq_session = False
self.arq_session_state = 'disconnected'
self.audio_dbfs = 0 self.audio_dbfs = 0
def set(self, key, value): def set(self, key, value):