Merge branch 'FM' into dstar_correlator_fm

IO.cpp

@@ -26,12 +26,31 @@
 static q31_t   DC_FILTER[] = {3367972, 0, 3367972, 0, 2140747704, 0}; // {b0, 0, b1, b2, -a1, -a2}
 const uint32_t DC_FILTER_STAGES = 1U; // One Biquad stage
 
-// One symbol boxcar filters
-static q15_t   BOXCAR5_FILTER[] = {12000, 12000, 12000, 12000, 12000, 0};
-const uint16_t BOXCAR5_FILTER_LEN = 6U;
+// Generated using rcosdesign(0.2, 8, 5, 'sqrt') in MATLAB
+static q15_t RRC_0_2_FILTER[] = {401, 104, -340, -731, -847, -553, 112, 909, 1472, 1450, 683, -675, -2144, -3040, -2706, -770, 2667, 6995,
+                                 11237, 14331, 15464, 14331, 11237, 6995, 2667, -770, -2706, -3040, -2144, -675, 683, 1450, 1472, 909, 112,
+                                 -553, -847, -731, -340, 104, 401, 0};
+const uint16_t RRC_0_2_FILTER_LEN = 42U;
 
-static q15_t   BOXCAR10_FILTER[] = {6000, 6000, 6000, 6000, 6000, 6000, 6000, 6000, 6000, 6000};
-const uint16_t BOXCAR10_FILTER_LEN = 10U;
+// Generated using rcosdesign(0.2, 8, 10, 'sqrt') in MATLAB
+static q15_t NXDN_0_2_FILTER[] = {284, 198, 73, -78, -240, -393, -517, -590, -599, -533, -391, -181, 79, 364, 643, 880, 1041, 1097, 1026, 819,
+                                  483, 39, -477, -1016, -1516, -1915, -2150, -2164, -1914, -1375, -545, 557, 1886, 3376, 4946, 6502, 7946, 9184,
+                                  10134, 10731, 10935, 10731, 10134, 9184, 7946, 6502, 4946, 3376, 1886, 557, -545, -1375, -1914, -2164, -2150,
+                                  -1915, -1516, -1016, -477, 39, 483, 819, 1026, 1097, 1041, 880, 643, 364, 79, -181, -391, -533, -599, -590,
+                                  -517, -393, -240, -78, 73, 198, 284, 0};
+const uint16_t NXDN_0_2_FILTER_LEN = 82U;
+
+static q15_t NXDN_ISINC_FILTER[] = {790, -1085, -1073, -553, 747, 2341, 3156, 2152, -893, -4915, -7834, -7536, -3102, 4441, 12354, 17394, 17394,
+                                   12354, 4441, -3102, -7536, -7834, -4915, -893, 2152, 3156, 2341, 747, -553, -1073, -1085, 790};
+const uint16_t NXDN_ISINC_FILTER_LEN = 32U;
+
+// Generated using gaussfir(0.5, 4, 5) in MATLAB
+static q15_t   GAUSSIAN_0_5_FILTER[] = {8, 104, 760, 3158, 7421, 9866, 7421, 3158, 760, 104, 8, 0};
+const uint16_t GAUSSIAN_0_5_FILTER_LEN = 12U;
+
+// One symbol boxcar filter
+static q15_t   BOXCAR_FILTER[] = {12000, 12000, 12000, 12000, 12000, 0};
+const uint16_t BOXCAR_FILTER_LEN = 6U;
 
 const uint16_t DC_OFFSET = 2048U;
 
@@ -42,10 +61,16 @@ m_txBuffer(TX_RINGBUFFER_SIZE),
 m_rssiBuffer(RX_RINGBUFFER_SIZE),
 m_dcFilter(),
 m_dcState(),
-m_boxcar5Filter(),
-m_boxcar10Filter(),
-m_boxcar5State(),
-m_boxcar10State(),
+m_rrcFilter(),
+m_gaussianFilter(),
+m_boxcarFilter(),
+m_nxdnFilter(),
+m_nxdnISincFilter(),
+m_rrcState(),
+m_gaussianState(),
+m_boxcarState(),
+m_nxdnState(),
+m_nxdnISincState(),
 m_pttInvert(false),
 m_rxLevel(128 * 128),
 m_cwIdTXLevel(128 * 128),
@@ -66,22 +91,37 @@ m_dacOverflow(0U),
 m_watchdog(0U),
 m_lockout(false)
 {
-  ::memset(m_boxcar5State,  0x00U, 30U * sizeof(q15_t));
-  ::memset(m_boxcar10State, 0x00U, 40U * sizeof(q15_t));
-  ::memset(m_dcState,       0x00U,  4U * sizeof(q31_t));
+  ::memset(m_rrcState,      0x00U,  70U * sizeof(q15_t));
+  ::memset(m_gaussianState, 0x00U,  40U * sizeof(q15_t));
+  ::memset(m_boxcarState,   0x00U,  30U * sizeof(q15_t));
+  ::memset(m_nxdnState,     0x00U, 110U * sizeof(q15_t));
+  ::memset(m_nxdnISincState, 0x00U, 60U * sizeof(q15_t));
+  ::memset(m_dcState,       0x00U,   4U * sizeof(q31_t));
 
   m_dcFilter.numStages = DC_FILTER_STAGES;
   m_dcFilter.pState    = m_dcState;
   m_dcFilter.pCoeffs   = DC_FILTER;
   m_dcFilter.postShift = 0;
 
-  m_boxcar5Filter.numTaps = BOXCAR5_FILTER_LEN;
-  m_boxcar5Filter.pState  = m_boxcar5State;
-  m_boxcar5Filter.pCoeffs = BOXCAR5_FILTER;
+  m_rrcFilter.numTaps = RRC_0_2_FILTER_LEN;
+  m_rrcFilter.pState  = m_rrcState;
+  m_rrcFilter.pCoeffs = RRC_0_2_FILTER;
 
-  m_boxcar10Filter.numTaps = BOXCAR10_FILTER_LEN;
-  m_boxcar10Filter.pState  = m_boxcar10State;
-  m_boxcar10Filter.pCoeffs = BOXCAR10_FILTER;
+  m_gaussianFilter.numTaps = GAUSSIAN_0_5_FILTER_LEN;
+  m_gaussianFilter.pState  = m_gaussianState;
+  m_gaussianFilter.pCoeffs = GAUSSIAN_0_5_FILTER;
+
+  m_boxcarFilter.numTaps = BOXCAR_FILTER_LEN;
+  m_boxcarFilter.pState  = m_boxcarState;
+  m_boxcarFilter.pCoeffs = BOXCAR_FILTER;
+  
+  m_nxdnFilter.numTaps = NXDN_0_2_FILTER_LEN;
+  m_nxdnFilter.pState  = m_nxdnState;
+  m_nxdnFilter.pCoeffs = NXDN_0_2_FILTER;
+  
+  m_nxdnISincFilter.numTaps = NXDN_ISINC_FILTER_LEN;
+  m_nxdnISincFilter.pState  = m_nxdnISincState;
+  m_nxdnISincFilter.pCoeffs = NXDN_ISINC_FILTER;
 
   initInt();
   
@@ -268,35 +308,52 @@ void CIO::process()
 #endif
 
     if (m_modemState == STATE_IDLE) {
-      if (m_dstarEnable || m_dmrEnable || m_ysfEnable || m_p25Enable) {
-        q15_t vals[RX_BLOCK_SIZE];
-        ::arm_fir_fast_q15(&m_boxcar5Filter, samples, vals, RX_BLOCK_SIZE);
+      if (m_dstarEnable) {
+        q15_t GMSKVals[RX_BLOCK_SIZE];
+#if defined(USE_DCBLOCKER)
+        ::arm_fir_fast_q15(&m_gaussianFilter, dcSamples, GMSKVals, RX_BLOCK_SIZE);
+#else
+        ::arm_fir_fast_q15(&m_gaussianFilter, samples, GMSKVals, RX_BLOCK_SIZE);
+#endif
+        dstarRX.samples(GMSKVals, rssi, RX_BLOCK_SIZE);
+      }
 
-        if (m_dstarEnable)
-          dstarRX.samples(vals, rssi, RX_BLOCK_SIZE);
-
-        if (m_p25Enable)
-          p25RX.samples(vals, rssi, RX_BLOCK_SIZE);
-
-        if (m_ysfEnable)
-          ysfRX.samples(vals, rssi, RX_BLOCK_SIZE);
-
-        if (m_dmrEnable) {
-          if (m_duplex)
-            dmrIdleRX.samples(vals, RX_BLOCK_SIZE);
-          else
-            dmrDMORX.samples(vals, rssi, RX_BLOCK_SIZE);
-        }
+      if (m_p25Enable) {
+        q15_t P25Vals[RX_BLOCK_SIZE];
+#if defined(USE_DCBLOCKER)
+        ::arm_fir_fast_q15(&m_boxcarFilter, dcSamples, P25Vals, RX_BLOCK_SIZE);
+#else
+        ::arm_fir_fast_q15(&m_boxcarFilter, samples, P25Vals, RX_BLOCK_SIZE);
+#endif
+        p25RX.samples(P25Vals, rssi, RX_BLOCK_SIZE);
       }
 
       if (m_nxdnEnable) {
-        q15_t vals[RX_BLOCK_SIZE];
+        q15_t NXDNValsTmp[RX_BLOCK_SIZE];
 #if defined(USE_DCBLOCKER)
-        ::arm_fir_fast_q15(&m_boxcar10Filter, dcSamples, vals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_nxdnFilter, dcSamples, NXDNValsTmp, RX_BLOCK_SIZE);
 #else
-        ::arm_fir_fast_q15(&m_boxcar10Filter, samples, vals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_nxdnFilter, samples, NXDNValsTmp, RX_BLOCK_SIZE);
 #endif
-        nxdnRX.samples(vals, rssi, RX_BLOCK_SIZE);
+        q15_t NXDNVals[RX_BLOCK_SIZE];
+        ::arm_fir_fast_q15(&m_nxdnISincFilter, NXDNValsTmp, NXDNVals, RX_BLOCK_SIZE);
+
+        nxdnRX.samples(NXDNVals, rssi, RX_BLOCK_SIZE);
+      }
+
+      if (m_dmrEnable || m_ysfEnable) {
+        q15_t RRCVals[RX_BLOCK_SIZE];
+        ::arm_fir_fast_q15(&m_rrcFilter, samples, RRCVals, RX_BLOCK_SIZE);
+
+        if (m_ysfEnable)
+          ysfRX.samples(RRCVals, rssi, RX_BLOCK_SIZE);
+
+        if (m_dmrEnable) {
+          if (m_duplex)
+            dmrIdleRX.samples(RRCVals, RX_BLOCK_SIZE);
+          else
+            dmrDMORX.samples(RRCVals, rssi, RX_BLOCK_SIZE);
+        }
       }
 
       if (m_fmEnable) {
@@ -309,59 +366,61 @@ void CIO::process()
       }
     } else if (m_modemState == STATE_DSTAR) {
       if (m_dstarEnable) {
-        q15_t vals[RX_BLOCK_SIZE];
+        q15_t GMSKVals[RX_BLOCK_SIZE];
 #if defined(USE_DCBLOCKER)
-        ::arm_fir_fast_q15(&m_boxcar5Filter, dcSamples, vals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_gaussianFilter, dcSamples, GMSKVals, RX_BLOCK_SIZE);
 #else
-        ::arm_fir_fast_q15(&m_boxcar5Filter, samples, vals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_gaussianFilter, samples, GMSKVals, RX_BLOCK_SIZE);
 #endif
-
-        dstarRX.samples(vals, rssi, RX_BLOCK_SIZE);
+        dstarRX.samples(GMSKVals, rssi, RX_BLOCK_SIZE);
       }
     } else if (m_modemState == STATE_DMR) {
       if (m_dmrEnable) {
-        q15_t vals[RX_BLOCK_SIZE];
-        ::arm_fir_fast_q15(&m_boxcar5Filter, samples, vals, RX_BLOCK_SIZE);
+        q15_t DMRVals[RX_BLOCK_SIZE];
+        ::arm_fir_fast_q15(&m_rrcFilter, samples, DMRVals, RX_BLOCK_SIZE);
 
         if (m_duplex) {
           // If the transmitter isn't on, use the DMR idle RX to detect the wakeup CSBKs
           if (m_tx)
-            dmrRX.samples(vals, rssi, control, RX_BLOCK_SIZE);
+            dmrRX.samples(DMRVals, rssi, control, RX_BLOCK_SIZE);
           else
-            dmrIdleRX.samples(vals, RX_BLOCK_SIZE);
+            dmrIdleRX.samples(DMRVals, RX_BLOCK_SIZE);
         } else {
-          dmrDMORX.samples(vals, rssi, RX_BLOCK_SIZE);
+          dmrDMORX.samples(DMRVals, rssi, RX_BLOCK_SIZE);
         }
       }
     } else if (m_modemState == STATE_YSF) {
       if (m_ysfEnable) {
-        q15_t vals[RX_BLOCK_SIZE];
+        q15_t YSFVals[RX_BLOCK_SIZE];
 #if defined(USE_DCBLOCKER)
-        ::arm_fir_fast_q15(&m_boxcar5Filter, dcSamples, vals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_rrcFilter, dcSamples, YSFVals, RX_BLOCK_SIZE);
 #else
-        ::arm_fir_fast_q15(&m_boxcar5Filter, samples, vals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_rrcFilter, samples, YSFVals, RX_BLOCK_SIZE);
 #endif
-        ysfRX.samples(vals, rssi, RX_BLOCK_SIZE);
+        ysfRX.samples(YSFVals, rssi, RX_BLOCK_SIZE);
       }
     } else if (m_modemState == STATE_P25) {
       if (m_p25Enable) {
-        q15_t vals[RX_BLOCK_SIZE];
+        q15_t P25Vals[RX_BLOCK_SIZE];
 #if defined(USE_DCBLOCKER)
-        ::arm_fir_fast_q15(&m_boxcar5Filter, dcSamples, vals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_boxcarFilter, dcSamples, P25Vals, RX_BLOCK_SIZE);
 #else
-        ::arm_fir_fast_q15(&m_boxcar5Filter, samples, vals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_boxcarFilter, samples, P25Vals, RX_BLOCK_SIZE);
 #endif
-        p25RX.samples(vals, rssi, RX_BLOCK_SIZE);
+        p25RX.samples(P25Vals, rssi, RX_BLOCK_SIZE);
       }
-	} else if (m_modemState == STATE_NXDN) {
+    } else if (m_modemState == STATE_NXDN) {
       if (m_nxdnEnable) {
-        q15_t vals[RX_BLOCK_SIZE];
+        q15_t NXDNValsTmp[RX_BLOCK_SIZE];
 #if defined(USE_DCBLOCKER)
-        ::arm_fir_fast_q15(&m_boxcar10Filter, dcSamples, vals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_nxdnFilter, dcSamples, NXDNValsTmp, RX_BLOCK_SIZE);
 #else
-        ::arm_fir_fast_q15(&m_boxcar10Filter, samples, vals, RX_BLOCK_SIZE);
+        ::arm_fir_fast_q15(&m_nxdnFilter, samples, NXDNValsTmp, RX_BLOCK_SIZE);
 #endif
-        nxdnRX.samples(vals, rssi, RX_BLOCK_SIZE);
+        q15_t NXDNVals[RX_BLOCK_SIZE];
+        ::arm_fir_fast_q15(&m_nxdnISincFilter, NXDNValsTmp, NXDNVals, RX_BLOCK_SIZE);
+
+        nxdnRX.samples(NXDNVals, rssi, RX_BLOCK_SIZE);
       }
     } else if (m_modemState == STATE_FM) {
       bool cos = getCOSInt();
@@ -371,13 +430,10 @@ void CIO::process()
       fm.samples(cos, samples, RX_BLOCK_SIZE);
 #endif
     } else if (m_modemState == STATE_DSTARCAL) {
-      q15_t vals[RX_BLOCK_SIZE];
-#if defined(USE_DCBLOCKER)
-      ::arm_fir_fast_q15(&m_boxcar5Filter, dcSamples, vals, RX_BLOCK_SIZE);
-#else
-      ::arm_fir_fast_q15(&m_boxcar5Filter, samples, vals, RX_BLOCK_SIZE);
-#endif
-      calDStarRX.samples(vals, RX_BLOCK_SIZE);
+      q15_t GMSKVals[RX_BLOCK_SIZE];
+      ::arm_fir_fast_q15(&m_gaussianFilter, samples, GMSKVals, RX_BLOCK_SIZE);
+
+      calDStarRX.samples(GMSKVals, RX_BLOCK_SIZE);
     } else if (m_modemState == STATE_RSSICAL) {
       calRSSI.samples(rssi, RX_BLOCK_SIZE);
     }

IO.h

@@ -66,10 +66,16 @@ private:
   arm_biquad_casd_df1_inst_q31 m_dcFilter;
   q31_t                        m_dcState[4];
 
-  arm_fir_instance_q15 m_boxcar5Filter;
-  arm_fir_instance_q15 m_boxcar10Filter;
-  q15_t                m_boxcar5State[30U];        // NoTaps + BlockSize - 1, 6 + 20 - 1 plus some spare
-  q15_t                m_boxcar10State[40U];       // NoTaps + BlockSize - 1, 10 + 20 - 1 plus some spare
+  arm_fir_instance_q15 m_rrcFilter;
+  arm_fir_instance_q15 m_gaussianFilter;
+  arm_fir_instance_q15 m_boxcarFilter;
+  arm_fir_instance_q15 m_nxdnFilter;
+  arm_fir_instance_q15 m_nxdnISincFilter;
+  q15_t                m_rrcState[70U];           // NoTaps + BlockSize - 1, 42 + 20 - 1 plus some spare
+  q15_t                m_gaussianState[40U];      // NoTaps + BlockSize - 1, 12 + 20 - 1 plus some spare
+  q15_t                m_boxcarState[30U];        // NoTaps + BlockSize - 1, 6 + 20 - 1 plus some spare
+  q15_t                m_nxdnState[110U];         // NoTaps + BlockSize - 1, 82 + 20 - 1 plus some spare
+  q15_t                m_nxdnISincState[60U];     // NoTaps + BlockSize - 1, 32 + 20 - 1 plus some spare
 
   bool                 m_pttInvert;
   q15_t                m_rxLevel;