Merge remote-tracking branch 'g4klx/master'

Config.h

@@ -27,7 +27,7 @@
 // Frequencies such as 10.0 Mhz (48000 * 208.333) or 20 Mhz (48000 * 416.666) are not suitable.
 //
 // For 12 MHz
-// #define EXTERNAL_OSC 12000000
+#define EXTERNAL_OSC 12000000
 // For 12.288 MHz
 // #define EXTERNAL_OSC 12288000
 // For 14.4 MHz

DMRDMORX.cpp

@@ -88,7 +88,7 @@ bool CDMRDMORX::processSample(q15_t sample, uint16_t rssi)
   m_rssi[m_dataPtr] = rssi;
 
   m_bitBuffer[m_bitPtr] <<= 1;
-  if (sample < m_dc_level)
+  if (sample < 0)
     m_bitBuffer[m_bitPtr] |= 0x01U;
 
   if (m_state == DMORXS_NONE) {

DMRSlotRX.cpp

@@ -104,7 +104,7 @@ bool CDMRSlotRX::processSample(q15_t sample, uint16_t rssi)
   m_rssi[m_dataPtr] = rssi;
   
   m_bitBuffer[m_bitPtr] <<= 1;
-  if (sample < m_dc_level)
+  if (sample < 0)
     m_bitBuffer[m_bitPtr] |= 0x01U;
 
   if (m_state == DMRRXS_NONE) {

DStarRX.cpp

@@ -28,11 +28,7 @@ const uint32_t PLLMAX = 0x10000U;
 const uint32_t PLLINC = PLLMAX / DSTAR_RADIO_BIT_LENGTH;
 const uint32_t INC    = PLLINC / 32U;
 
-const unsigned int MAX_SYNC_BITS = 50U * DSTAR_DATA_LENGTH_BITS;
+const unsigned int MAX_SYNC_BITS = 100U * DSTAR_DATA_LENGTH_BITS;
-
-const unsigned int SYNC_POS        = 21U * DSTAR_DATA_LENGTH_BITS;
-const unsigned int SYNC_SCAN_START = SYNC_POS - 3U;
-const unsigned int SYNC_SCAN_END   = SYNC_POS + 3U;
 
 // D-Star bit order version of 0x55 0x55 0x6E 0x0A
 const uint32_t FRAME_SYNC_DATA = 0x00557650U;
@@ -241,6 +237,10 @@ const uint16_t CCITT_TABLE[] = {
   0xf78fU, 0xe606U, 0xd49dU, 0xc514U, 0xb1abU, 0xa022U, 0x92b9U, 0x8330U,
   0x7bc7U, 0x6a4eU, 0x58d5U, 0x495cU, 0x3de3U, 0x2c6aU, 0x1ef1U, 0x0f78U};
 
+// Generated using [b, a] = butter(1, 0.001) in MATLAB
+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
+
 CDStarRX::CDStarRX() :
 m_pll(0U),
 m_prev(false),
@@ -257,8 +257,16 @@ m_pathMemory2(),
 m_pathMemory3(),
 m_fecOutput(),
 m_rssiAccum(0U),
-m_rssiCount(0U)
+m_rssiCount(0U),
+m_dcFilter(),
+m_dcState()
 {
+  ::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;
 }
 
 void CDStarRX::reset()
@@ -273,13 +281,24 @@ void CDStarRX::reset()
   m_rssiCount     = 0U;
 }
 
-void CDStarRX::samples(const q15_t* samples, const uint16_t* rssi, uint8_t length)
+void CDStarRX::samples(q15_t* samples, const uint16_t* rssi, uint8_t length)
 {
+  q31_t dcLevel = 0;
+  q31_t dcVals[20U];
+  q31_t q31Samples[20U];
+
+  ::arm_q15_to_q31(samples, q31Samples, length);
+  ::arm_biquad_cascade_df1_q31(&m_dcFilter, q31Samples, dcVals, length);
+
+  for (uint8_t i = 0U; i < length; i++)
+    dcLevel += dcVals[i];
+  dcLevel /= length;
+
   for (uint16_t i = 0U; i < length; i++) {
     m_rssiAccum += rssi[i];
     m_rssiCount++;
 
-    bool bit = samples[i] < m_dc_level;
+    bool bit = (q31Samples[i] - dcLevel) < 0;
 
     if (bit != m_prev) {
       if (m_pll < (PLLMAX / 2U))
@@ -349,7 +368,7 @@ void CDStarRX::processNone(bool bit)
     ::memset(m_rxBuffer, 0x00U, DSTAR_DATA_LENGTH_BYTES + 2U);
     m_rxBufferBits = 0U;
 
-    m_dataBits  = 0U;
+    m_dataBits  = MAX_SYNC_BITS;
     m_rxState   = DSRXS_DATA;
     return;
   }
@@ -378,8 +397,8 @@ void CDStarRX::processHeader(bool bit)
       ::memset(m_rxBuffer, 0x00U, DSTAR_DATA_LENGTH_BYTES + 2U);
       m_rxBufferBits = 0U;
 
-      m_rxState   = DSRXS_DATA;
+      m_rxState  = DSRXS_DATA;
-      m_dataBits  = SYNC_POS - DSTAR_DATA_LENGTH_BITS + 1U;
+      m_dataBits = MAX_SYNC_BITS;
     } else {
       // The checksum failed, return to looking for syncs
       m_rxState = DSRXS_NONE;
@@ -411,37 +430,29 @@ void CDStarRX::processData(bool bit)
 
   // Fuzzy matching of the data sync bit sequence
   bool syncSeen = false;
-  if (m_dataBits >= SYNC_SCAN_START && m_dataBits <= (SYNC_POS + 1U)) {
+  if (m_rxBufferBits >= (DSTAR_DATA_LENGTH_BITS - 3U)) {
     if (countBits32((m_patternBuffer & DATA_SYNC_MASK) ^ DATA_SYNC_DATA) <= DATA_SYNC_ERRS) {
-      if (m_dataBits < SYNC_POS)
-        DEBUG2("DStarRX: found data sync in Data, early", SYNC_POS - m_dataBits);
-      else
-        DEBUG1("DStarRX: found data sync in Data");
-
       m_rxBufferBits = DSTAR_DATA_LENGTH_BITS;
-      m_dataBits = 0U;
+      m_dataBits     = MAX_SYNC_BITS;
-      syncSeen   = true;
+      syncSeen       = true;
     }
   }
 
   // Check to see if the sync is arriving late
-  if (m_dataBits == SYNC_POS) {
+  if (m_rxBufferBits == DSTAR_DATA_LENGTH_BITS && !syncSeen) {
     for (uint8_t i = 1U; i <= 3U; i++) {
       uint32_t syncMask = DATA_SYNC_MASK >> i;
       uint32_t syncData = DATA_SYNC_DATA >> i;
       if (countBits32((m_patternBuffer & syncMask) ^ syncData) <= DATA_SYNC_ERRS) {
-        DEBUG2("DStarRX: found data sync in Data, late", i);
         m_rxBufferBits -= i;
-        m_dataBits     -= i;
         break;
       }
     }
   }
 
-  m_dataBits++;
+  m_dataBits--;
 
-  // We've not seen a data sync for too long, signal RXLOST and change to RX_NONE
+  if (m_dataBits == 0U) {
-  if (m_dataBits >= MAX_SYNC_BITS) {
     DEBUG1("DStarRX: data sync timed out, lost lock");
 
     io.setDecode(false);

DStarRX.h

@@ -32,7 +32,7 @@ class CDStarRX {
 public:
   CDStarRX();
 
-  void samples(const q15_t* samples, const uint16_t* rssi, uint8_t length);
+  void samples(q15_t* samples, const uint16_t* rssi, uint8_t length);
 
   void reset();
 
@@ -53,6 +53,8 @@ private:
   uint8_t      m_fecOutput[42U];
   uint32_t     m_rssiAccum;
   uint16_t     m_rssiCount;
+  arm_biquad_casd_df1_inst_q31 m_dcFilter;
+  q31_t                        m_dcState[4];
   
   void    processNone(bool bit);
   void    processHeader(bool bit);

Globals.h

@@ -1,5 +1,5 @@
 /*
- *   Copyright (C) 2015,2016 by Jonathan Naylor G4KLX
+ *   Copyright (C) 2015,2016,2017 by Jonathan Naylor G4KLX
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -93,8 +93,6 @@ extern bool m_duplex;
 extern bool m_tx;
 extern bool m_dcd;
 
-extern q15_t m_dc_level;
-
 extern CSerialPort serial;
 extern CIO io;
 

IO.cpp

@@ -33,13 +33,9 @@ static q15_t   GAUSSIAN_0_5_FILTER[] = {8, 104, 760, 3158, 7421, 9866, 7421, 315
 const uint16_t GAUSSIAN_0_5_FILTER_LEN = 12U;
 
 // One symbol boxcar filter
-static q15_t   BOXCAR_FILTER[] = {3000, 3000, 3000, 3000, 3000, 0};
+static q15_t   BOXCAR_FILTER[] = {12000, 12000, 12000, 12000, 12000, 0};
 const uint16_t BOXCAR_FILTER_LEN = 6U;
 
-// Generated using [b, a] = butter(1, 0.001) in MATLAB
-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
-
 const uint16_t DC_OFFSET = 2048U;
 
 CIO::CIO() :
@@ -66,14 +62,11 @@ m_detect(false),
 m_adcOverflow(0U),
 m_dacOverflow(0U),
 m_watchdog(0U),
-m_lockout(false),
+m_lockout(false)
-m_dcFilter(),
-m_dcState()
 {
   ::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_dcState,       0x00U, 4U * sizeof(q31_t));
 
   m_rrcFilter.numTaps = RRC_0_2_FILTER_LEN;
   m_rrcFilter.pState  = m_rrcState;
@@ -87,11 +80,6 @@ m_dcState()
   m_boxcarFilter.pState  = m_boxcarState;
   m_boxcarFilter.pCoeffs = BOXCAR_FILTER;
   
-  m_dcFilter.numStages = DC_FILTER_STAGES;
-  m_dcFilter.pState  = m_dcState;
-  m_dcFilter.pCoeffs = DC_FILTER;
-  m_dcFilter.postShift = 0;
-
   initInt();
 }
 
@@ -169,20 +157,6 @@ void CIO::process()
     if (m_lockout)
       return;
 
-    q31_t dc_level = 0;
-    q31_t dcVals[20];
-    q31_t intSamp[20];
-  
-    ::arm_q15_to_q31((q15_t*)samples, intSamp, RX_BLOCK_SIZE);
-    ::arm_biquad_cascade_df1_q31(&m_dcFilter, intSamp, dcVals, RX_BLOCK_SIZE);
-
-    for (uint8_t i = 0U; i < RX_BLOCK_SIZE; i++)
-      dc_level += dcVals[i];
-
-    dc_level /= RX_BLOCK_SIZE;
-    
-    m_dc_level = (q15_t) (dc_level >> 16);
-
     if (m_modemState == STATE_IDLE) {
       if (m_dstarEnable) {
         q15_t GMSKVals[RX_BLOCK_SIZE];

IO.h

@@ -66,8 +66,6 @@ private:
   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
-  arm_biquad_casd_df1_inst_q31 m_dcFilter;
-  q31_t                        m_dcState[4];
 
   bool                 m_pttInvert;
   q15_t                m_rxLevel;

MMDVM.cpp

@@ -36,8 +36,6 @@ bool m_duplex = true;
 bool m_tx  = false;
 bool m_dcd = false;
 
-q15_t m_dc_level = 0;
-
 CDStarRX   dstarRX;
 CDStarTX   dstarTX;
 

MMDVM.ino

@@ -33,8 +33,6 @@ bool m_duplex = true;
 bool m_tx  = false;
 bool m_dcd = false;
 
-q15_t m_dc_level = 0;
-
 CDStarRX   dstarRX;
 CDStarTX   dstarTX;
 

P25RX.cpp

@@ -38,6 +38,10 @@ const uint16_t NOENDPTR = 9999U;
 
 const unsigned int MAX_SYNC_FRAMES = 4U + 1U;
 
+// Generated using [b, a] = butter(1, 0.001) in MATLAB
+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
+
 CP25RX::CP25RX() :
 m_state(P25RXS_NONE),
 m_bitBuffer(),
@@ -60,8 +64,16 @@ m_threshold(),
 m_thresholdVal(0),
 m_averagePtr(NOAVEPTR),
 m_rssiAccum(0U),
-m_rssiCount(0U)
+m_rssiCount(0U),
+m_dcFilter(),
+m_dcState()
 {
+  ::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;
 }
 
 void CP25RX::reset()
@@ -86,16 +98,29 @@ void CP25RX::reset()
   m_rssiCount     = 0U;
 }
 
-void CP25RX::samples(const q15_t* samples, uint16_t* rssi, uint8_t length)
+void CP25RX::samples(q15_t* samples, uint16_t* rssi, uint8_t length)
 {
+  q31_t dcLevel = 0;
+  q31_t dcVals[20U];
+  q31_t q31Samples[20U];
+
+  ::arm_q15_to_q31(samples, q31Samples, length);
+  ::arm_biquad_cascade_df1_q31(&m_dcFilter, q31Samples, dcVals, length);
+
+  for (uint8_t i = 0U; i < length; i++)
+    dcLevel += dcVals[i];
+  dcLevel /= length;
+
+  q15_t offset = q15_t(__SSAT((dcLevel >> 16), 16));;
+
   for (uint8_t i = 0U; i < length; i++) {
-    q15_t sample = samples[i];
+    q15_t sample = samples[i] - offset;
 
     m_rssiAccum += rssi[i];
     m_rssiCount++;
 
     m_bitBuffer[m_bitPtr] <<= 1;
-    if (sample < m_dc_level)
+    if (sample < 0)
       m_bitBuffer[m_bitPtr] |= 0x01U;
 
     m_buffer[m_dataPtr] = sample;

P25RX.h

@@ -32,7 +32,7 @@ class CP25RX {
 public:
   CP25RX();
 
-  void samples(const q15_t* samples, uint16_t* rssi, uint8_t length);
+  void samples(q15_t* samples, uint16_t* rssi, uint8_t length);
 
   void reset();
 
@@ -59,6 +59,8 @@ private:
   uint8_t     m_averagePtr;
   uint32_t    m_rssiAccum;
   uint16_t    m_rssiCount;
+  arm_biquad_casd_df1_inst_q31 m_dcFilter;
+  q31_t                        m_dcState[4];
 
   void processNone(q15_t sample);
   void processHdr(q15_t sample);

YSFRX.cpp

@@ -38,6 +38,10 @@ const uint16_t NOENDPTR = 9999U;
 
 const unsigned int MAX_SYNC_FRAMES = 4U + 1U;
 
+// Generated using [b, a] = butter(1, 0.001) in MATLAB
+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
+
 CYSFRX::CYSFRX() :
 m_state(YSFRXS_NONE),
 m_bitBuffer(),
@@ -58,8 +62,16 @@ m_threshold(),
 m_thresholdVal(0),
 m_averagePtr(NOAVEPTR),
 m_rssiAccum(0U),
-m_rssiCount(0U)
+m_rssiCount(0U),
+m_dcFilter(),
+m_dcState()
 {
+  ::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;
 }
 
 void CYSFRX::reset()
@@ -82,16 +94,29 @@ void CYSFRX::reset()
   m_rssiCount    = 0U;
 }
 
-void CYSFRX::samples(const q15_t* samples, uint16_t* rssi, uint8_t length)
+void CYSFRX::samples(q15_t* samples, uint16_t* rssi, uint8_t length)
 {
+  q31_t dcLevel = 0;
+  q31_t dcVals[20U];
+  q31_t q31Samples[20U];
+
+  ::arm_q15_to_q31(samples, q31Samples, length);
+  ::arm_biquad_cascade_df1_q31(&m_dcFilter, q31Samples, dcVals, length);
+
+  for (uint8_t i = 0U; i < length; i++)
+    dcLevel += dcVals[i];
+  dcLevel /= length;
+
+  q15_t offset = q15_t(__SSAT((dcLevel >> 16), 16));;
+
   for (uint8_t i = 0U; i < length; i++) {
-    q15_t sample = samples[i];
+    q15_t sample = samples[i] - offset;
 
     m_rssiAccum += rssi[i];
     m_rssiCount++;
 
     m_bitBuffer[m_bitPtr] <<= 1;
-    if (sample < m_dc_level)
+    if (sample < 0)
       m_bitBuffer[m_bitPtr] |= 0x01U;
 
     m_buffer[m_dataPtr] = sample;

YSFRX.h

@@ -31,7 +31,7 @@ class CYSFRX {
 public:
   CYSFRX();
 
-  void samples(const q15_t* samples, uint16_t* rssi, uint8_t length);
+  void samples(q15_t* samples, uint16_t* rssi, uint8_t length);
 
   void reset();
 
@@ -56,6 +56,8 @@ private:
   uint8_t     m_averagePtr;
   uint32_t    m_rssiAccum;
   uint16_t    m_rssiCount;
+  arm_biquad_casd_df1_inst_q31 m_dcFilter;
+  q31_t                        m_dcState[4];
 
   void processNone(q15_t sample);
   void processData(q15_t sample);