WIP ARQ - cleanup and fixes

modem/arq_session_irs.py

@@ -90,7 +90,7 @@ class ARQSessionIRS(arq_session.ARQSession):
             self.dxcall, 
             self.version,
             self.snr[0])
-        self.launch_transmit_and_wait(ack_frame, self.TIMEOUT_CONNECT, mode=FREEDV_MODE.datac13)
+        self.launch_transmit_and_wait(ack_frame, self.TIMEOUT_CONNECT, mode=FREEDV_MODE.signalling)
         self.set_state(self.STATE_OPEN_ACK_SENT)
 
     def send_info_ack(self, info_frame):
@@ -104,7 +104,7 @@ class ARQSessionIRS(arq_session.ARQSession):
         info_ack = self.frame_factory.build_arq_session_info_ack(
             self.id, self.total_crc, self.snr[0],
             self.speed_level, self.frames_per_burst)
-        self.launch_transmit_and_wait(info_ack, self.TIMEOUT_CONNECT, mode=FREEDV_MODE.datac13)
+        self.launch_transmit_and_wait(info_ack, self.TIMEOUT_CONNECT, mode=FREEDV_MODE.signalling)
         self.set_state(self.STATE_INFO_ACK_SENT)
 
     def send_burst_nack(self):

modem/arq_session_iss.py

@@ -71,7 +71,7 @@ class ARQSessionISS(arq_session.ARQSession):
 
     def start(self):
         session_open_frame = self.frame_factory.build_arq_session_open(self.dxcall, self.id)
-        self.launch_twr(session_open_frame, self.TIMEOUT_CONNECT_ACK, self.RETRIES_CONNECT, mode=FREEDV_MODE.datac13)
+        self.launch_twr(session_open_frame, self.TIMEOUT_CONNECT_ACK, self.RETRIES_CONNECT, mode=FREEDV_MODE.signalling)
         self.set_state(self.STATE_OPEN_SENT)
 
     def set_speed_and_frames_per_burst(self, frame):
@@ -84,7 +84,7 @@ class ARQSessionISS(arq_session.ARQSession):
         info_frame = self.frame_factory.build_arq_session_info(self.id, len(self.data), 
                                                                helpers.get_crc_32(self.data), 
                                                                self.snr[0])
-        self.launch_twr(info_frame, self.TIMEOUT_CONNECT_ACK, self.RETRIES_CONNECT, mode=FREEDV_MODE.datac13)
+        self.launch_twr(info_frame, self.TIMEOUT_CONNECT_ACK, self.RETRIES_CONNECT, mode=FREEDV_MODE.signalling)
         self.set_state(self.STATE_INFO_SENT)
 
     def send_data(self, irs_frame):

modem/codec2.py

@@ -24,8 +24,7 @@ class FREEDV_MODE(Enum):
     """
     Enumeration for codec2 modes and names
     """
-    sig0 = 19
+    signalling = 19
-    sig1 = 19
     datac0 = 14
     datac1 = 10
     datac3 = 12

modem/command.py

@@ -30,11 +30,7 @@ class TxCommand():
         pass
 
     def get_tx_mode(self):
-        return (
+        return FREEDV_MODE.signalling
-            FREEDV_MODE.fsk_ldpc_0.value
-            if self.config['MODEM']['enable_fsk']
-            else FREEDV_MODE.sig0.value
-        )
     
     def make_modem_queue_item(self, mode, repeat, repeat_delay, frame):
         return {

modem/modem.py

@@ -14,7 +14,6 @@ import ctypes
 import queue
 import threading
 import time
-from collections import deque
 import codec2
 import numpy as np
 import sounddevice as sd
@@ -47,8 +46,6 @@ class RF:
 
         self.tx_audio_level = config['AUDIO']['tx_audio_level']
         self.enable_audio_auto_tune = config['AUDIO']['enable_auto_tune']
-        #Dynamically enable FFT data stream when a client connects to FFT web socket
-        self.enable_fft_stream = False
         self.tx_delay = config['MODEM']['tx_delay']
 
         self.radiocontrol = config['RADIO']['control']
@@ -272,11 +269,12 @@ class RF:
         self.demodulator.reset_data_sync()
         # get freedv instance by mode
         mode_transition = {
-            codec2.FREEDV_MODE.datac0.value: self.freedv_datac0_tx,
+            codec2.FREEDV_MODE.signalling: self.freedv_datac13_tx,
-            codec2.FREEDV_MODE.datac1.value: self.freedv_datac1_tx,
+            codec2.FREEDV_MODE.datac0: self.freedv_datac0_tx,
-            codec2.FREEDV_MODE.datac3.value: self.freedv_datac3_tx,
+            codec2.FREEDV_MODE.datac1: self.freedv_datac1_tx,
-            codec2.FREEDV_MODE.datac4.value: self.freedv_datac4_tx,
+            codec2.FREEDV_MODE.datac3: self.freedv_datac3_tx,
-            codec2.FREEDV_MODE.datac13.value: self.freedv_datac13_tx,
+            codec2.FREEDV_MODE.datac4: self.freedv_datac4_tx,
+            codec2.FREEDV_MODE.datac13: self.freedv_datac13_tx,
         }
         if mode in mode_transition:
             freedv = mode_transition[mode]
@@ -711,18 +709,12 @@ class RF:
                 # When our channel busy counter reaches 0, toggle state to False
                 if self.channel_busy_delay == 0:
                     self.states.set("channel_busy", False)
-            if (self.enable_fft_stream):
                 # erase queue if greater than 10
-                if self.fft_queue.qsize() >= 10:
+            if self.fft_queue.qsize() >= 10:
-                    self.fft_queue = queue.Queue()
+                self.fft_queue = queue.Queue()
-                self.fft_queue.put(dfftlist[:315]) # 315 --> bandwidth 3200
+            self.fft_queue.put(dfftlist[:315]) # 315 --> bandwidth 3200
         except Exception as err:
             self.log.error(f"[MDM] calculate_fft: Exception: {err}")
             self.log.debug("[MDM] Setting fft=0")
             # else 0
             self.fft_queue.put([0])
-
-    def set_FFT_stream(self, enable: bool):
-        # Set config boolean regarding wheter it should sent FFT data to queue
-        self.enable_fft_stream = enable
-

modem/server.py

@@ -240,9 +240,6 @@ def sock_events(sock):
 
 @sock.route('/fft')
 def sock_fft(sock):
-    if len(wsm.fft_client_list) == 0:
-        app.modem_service.put("fft:true")
-        print("Streaming data to FFT socket since a client is connected")
     wsm.handle_connection(sock, wsm.fft_client_list, app.modem_fft)
 
 @sock.route('/states')

modem/service_manager.py

@@ -17,7 +17,6 @@ class SM:
         self.config = self.app.config_manager.read()
         self.modem_events = app.modem_events
         self.modem_fft = app.modem_fft
-        self.enable_fft_stream = False
         self.modem_service = app.modem_service
         self.states = app.state_manager
 
@@ -49,14 +48,6 @@ class SM:
                 threading.Event().wait(0.5)
                 if self.start_modem():
                     self.modem_events.put(json.dumps({"freedata": "modem-event", "event": "restart"}))
-            elif cmd in ['fft:true']:
-                # Tell modem it should put FFT data in the queue
-                self.modem.set_FFT_stream(True)
-                self.enable_fft_stream=True
-            elif cmd in ['fft:false']:
-                # Tell modem it should not put FFT data in the queue
-                self.modem.set_FFT_stream(False)
-                self.enable_fft_stream=False
             else:
                 self.log.warning("[SVC] modem command processing failed", cmd=cmd, state=self.states.is_modem_running)
 
@@ -88,7 +79,6 @@ class SM:
         self.frame_dispatcher.start()
 
         self.states.set("is_modem_running", True)
-        self.modem.set_FFT_stream(self.enable_fft_stream)
         self.modem.start_modem()
 
         return True