GitHub/sdrtrunk
1
0
Fork 0
mirror of https://github.com/DSheirer/sdrtrunk.git synced 2026-11-12 16:47:31 -05:00
Code Issues Packages Projects Releases 2 Wiki Activity

#1067 P25 Phase 1 C4FM/LSM decoder redesign. (#2294)

Browse Source 
C4FM now uses SIMD differential decoding and soft sync detection.
LSM updated with soft sync detector and retains original Gardner error detector.
Adds new QPSK symbol view in the now playing channel tab.
Restores PLL error driven tuner Auto-PPM feature.
Deletes the demod viewer GUI application and all instrumented decoders
Updates DMR to send soft symbols to new symbol view in Now Playing.

Co-authored-by: Dennis Sheirer <dsheirer@github.com>
This commit is contained in:
Denny Sheirer
2025-11-16 06:52:17 -05:00
committed by GitHub
parent 48202da9e4
commit 0d886c272e
149 changed files with 5990 additions and 8984 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
src/main/java/io/github/dsheirer/dsp/filter/design/FilterViewer.java
View File

@@ -20,6 +20,7 @@
package io.github.dsheirer.dsp.filter.design;
import io.github.dsheirer.dsp.filter.FilterFactory;
import io.github.dsheirer.dsp.filter.fir.FIRFilterSpecification;
import io.github.dsheirer.dsp.window.WindowType;
import javafx.application.Application;
import javafx.scene.Scene;
@@ -61,7 +62,26 @@ public class FilterViewer extends Application
int filterLength = 31;
WindowType windowType = WindowType.BLACKMAN_HARRIS_7;
float[] taps = FilterFactory.getHighPass(8000, 3000, filterLength, windowType);
FIRFilterSpecification specification = FIRFilterSpecification
.lowPassBuilder()
.sampleRate(12500)
.passBandCutoff(5200)
.passBandAmplitude(1.0).passBandRipple(0.01) //.01
.stopBandAmplitude(0.0).stopBandStart(6500) //6500
.stopBandRipple(0.01).build();
float[] taps = null;
try
{
taps = FilterFactory.getTaps(specification);
}
catch(Exception fde) //FilterDesignException
{
System.out.println("Error");
}
// float[] taps = FilterFactory.getHighPass(8000, 3000, filterLength, windowType);
// float[] taps = FilterFactory.getRootRaisedCosine(50000.0 / 4800.0, 20, 0.2f);
// taps = HilbertTransform.HALF_BAND_FILTER_47_TAP;

128
src/main/java/io/github/dsheirer/dsp/psk/DQPSKDecisionDirectedDemodulator.java
View File

@@ -1,128 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2024 Dennis Sheirer
*
* 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
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.dsp.psk;
import io.github.dsheirer.dsp.filter.interpolator.Interpolator;
import io.github.dsheirer.dsp.filter.interpolator.InterpolatorFactory;
import io.github.dsheirer.dsp.psk.pll.CostasLoop;
import io.github.dsheirer.dsp.psk.pll.IPhaseLockedLoop;
import io.github.dsheirer.dsp.symbol.Dibit;
import io.github.dsheirer.sample.complex.Complex;
import java.text.DecimalFormat;
public class DQPSKDecisionDirectedDemodulator extends PSKDemodulator<Dibit>
{
protected DQPSKDecisionDirectedSymbolEvaluator mSymbolEvaluator = new DQPSKDecisionDirectedSymbolEvaluator();
private Complex mPreviousPrecedingSample = new Complex(0, 0);
private Complex mPreviousCurrentSample = new Complex(0, 0);
private Complex mPrecedingSample = new Complex(0, 0);
private Complex mCurrentSample = new Complex(0, 0);
private Complex mPrecedingSymbol = new Complex(0, 0);
protected Complex mCurrentSymbol = new Complex(0, 0);
private final Interpolator mInterpolator = InterpolatorFactory.getInterpolator();
private static final DecimalFormat DECIMAL_FORMAT = new DecimalFormat("+#0.00000;-#0.00000");
private float[] mI = new float[15];
private float[] mQ = new float[15];
/**
* Decoder for Differential Quaternary Phase Shift Keying (DQPSK). This decoder uses both a Costas Loop (PLL) and
* a decision-directed DQPSK symbol timing and phase error detector to automatically align to the incoming carrier
* frequency and to adjust for any changes in symbol timing.
*
* This detector is optimized for constant amplitude DQPSK symbols like C4FM.
*
* @param phaseLockedLoop for tracking carrier frequency error
* @param interpolatingSampleBuffer to hold samples for interpolating a symbol
*/
public DQPSKDecisionDirectedDemodulator(IPhaseLockedLoop phaseLockedLoop, InterpolatingSampleBuffer interpolatingSampleBuffer)
{
super(interpolatingSampleBuffer, phaseLockedLoop);
}
@Override
public void receive(float inphase, float quadrature)
{
super.receive(inphase, quadrature);
System.arraycopy(mI, 1, mI, 0, mI.length - 1);
System.arraycopy(mQ, 1, mQ, 0, mQ.length - 1);
//Rotate the sample and add to buffer
Complex current = new Complex(inphase, quadrature);
current.normalizeFast();
current.multiply(getPLL().getCurrentVector());
mI[mI.length - 1] = current.inphase();
mQ[mQ.length - 1] = current.quadrature();
float iTemp = mInterpolator.filter(mI, 6, .416f);
float qTemp = mInterpolator.filter(mQ, 6, .416f);
float iSymbol = (mI[0] * iTemp) - (-mQ[0] * qTemp);
float qSymbol = (mI[0] * qTemp) + (iTemp * -mQ[0]);
float radians = (float)Math.atan2(iSymbol, qSymbol);
StringBuilder sb = new StringBuilder();
sb.append(DECIMAL_FORMAT.format(radians)).append(",");
sb.append(DECIMAL_FORMAT.format(((CostasLoop)getPLL()).getLoopFrequency()));
// System.out.println(sb);
}
/**
* Calculates a symbol from the interpolating buffer
*/
protected void calculateSymbol()
{
//Get preceding sample and an interpolated current sample from the interpolating buffer
mPrecedingSample = getInterpolatingSampleBuffer().getPrecedingSample();
mCurrentSample = getInterpolatingSampleBuffer().getCurrentSample();
//Differential decode preceding and current symbols by calculating the angular rotation between the previous and
//current samples (current sample x complex conjugate of previous sample).
//Note: preceding symbol is a preceding measurement of the current symbol that is simply used as a reference
//point to determine vector rotation to the current symbol -- it is not the true predecessor symbol
mPrecedingSymbol.setInphase(Complex.multiplyInphase(mPrecedingSample.inphase(), mPrecedingSample.quadrature(),
mPreviousPrecedingSample.inphase(), -mPreviousPrecedingSample.quadrature()));
mPrecedingSymbol.setQuadrature(Complex.multiplyQuadrature(mPrecedingSample.inphase(), mPrecedingSample.quadrature(),
mPreviousPrecedingSample.inphase(), -mPreviousPrecedingSample.quadrature()));
mCurrentSymbol.setInphase(Complex.multiplyInphase(mCurrentSample.inphase(), mCurrentSample.quadrature(),
mPreviousCurrentSample.inphase(), -mPreviousCurrentSample.quadrature()));
mCurrentSymbol.setQuadrature(Complex.multiplyQuadrature(mCurrentSample.inphase(), mCurrentSample.quadrature(),
mPreviousCurrentSample.inphase(), -mPreviousCurrentSample.quadrature()));
//Set gain to unity before we calculate the error value
mPrecedingSymbol.normalize();
mCurrentSymbol.normalize();
//Apply symbols to evaluator to calculate phase and timing error and make a symbol decision
mSymbolEvaluator.setSymbol(mPrecedingSymbol, mCurrentSymbol);
//Update the symbol timing error
getInterpolatingSampleBuffer().resetAndAdjust(mSymbolEvaluator.getTimingError());
//Update the costas loop (PLL) with any measured phase error
// getPLL().adjust(clip(mSymbolEvaluator.getPhaseError(), 0.5f));
//Store current samples/symbols to use for the next symbol period
mPreviousPrecedingSample.setValues(mPrecedingSample);
mPreviousCurrentSample.setValues(mCurrentSample);
broadcast(mSymbolEvaluator.getSymbolDecision());
}
}

147
src/main/java/io/github/dsheirer/dsp/psk/DQPSKDecisionDirectedDemodulatorInstrumented.java
View File

@@ -1,147 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2022 Dennis Sheirer
*
* 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
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.dsp.psk;
import io.github.dsheirer.dsp.psk.pll.CostasLoop;
import io.github.dsheirer.dsp.psk.pll.IPhaseLockedLoop;
import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.complex.Complex;
import io.github.dsheirer.sample.complex.ComplexSamples;
import org.apache.commons.math3.util.FastMath;
public class DQPSKDecisionDirectedDemodulatorInstrumented extends DQPSKDecisionDirectedDemodulator
{
private Listener<SymbolDecisionData> mSymbolDecisionDataListener;
private Listener<Double> mSamplesPerSymbolListener;
private Listener<Complex> mComplexSymbolListener;
private Listener<Double> mPLLErrorListener;
private Listener<Double> mPLLFrequencyListener;
private Listener<ComplexSamples> mFilteredGainAppliedComplexBufferListener;
private double mSampleRate;
/**
* Decoder for Differential Quaternary Phase Shift Keying (DQPSK). This decoder uses both a Costas Loop (PLL) and
* a custom DQPSK symbol timing error detector to automatically align to the incoming carrier frequency and to
* adjust for any changes in symbol timing.
*
* This detector is optimized for constant amplitude DQPSK symbols like C4FM.
*
* @param phaseLockedLoop for tracking carrier frequency error
* @param interpolatingSampleBuffer
* @param sampleRate of the incoming complex sample stream
*/
public DQPSKDecisionDirectedDemodulatorInstrumented(IPhaseLockedLoop phaseLockedLoop,
InterpolatingSampleBufferInstrumented interpolatingSampleBuffer,
double sampleRate)
{
super(phaseLockedLoop, interpolatingSampleBuffer);
mSampleRate = sampleRate;
}
@Override
public void receive(ComplexSamples complexSamples)
{
if(mFilteredGainAppliedComplexBufferListener != null)
{
mFilteredGainAppliedComplexBufferListener.receive(complexSamples);
}
super.receive(complexSamples);
}
/**
* Overrides the parent class symbol calculation to capture eye diagram data
*/
protected void calculateSymbol()
{
//Eye diagram listener
if(mSymbolDecisionDataListener != null)
{
mSymbolDecisionDataListener.receive(
((InterpolatingSampleBufferInstrumented)getInterpolatingSampleBuffer()).getSymbolDecisionData());
}
super.calculateSymbol();
if(mSamplesPerSymbolListener != null)
{
mSamplesPerSymbolListener.receive((double)getInterpolatingSampleBuffer().getSamplingPoint());
}
//Send to an external constellation symbol listener when registered
if(mComplexSymbolListener != null)
{
mComplexSymbolListener.receive(mCurrentSymbol);
}
if(mPLLErrorListener != null)
{
mPLLErrorListener.receive((double)mSymbolEvaluator.getPhaseError());
}
if(mPLLFrequencyListener != null)
{
double loopFrequency = ((CostasLoop)getPLL()).getLoopFrequency();
loopFrequency *= mSampleRate / (2.0 * FastMath.PI);
mPLLFrequencyListener.receive(loopFrequency);
}
}
/**
* Registers a listener to receive symbol decision data to produce an eye diagram.
*/
public void setSymbolDecisionDataListener(Listener<SymbolDecisionData> listener)
{
mSymbolDecisionDataListener = listener;
}
/**
* Registers the listener to receive PLL error values
*/
public void setSamplesPerSymbolListener(Listener<Double> listener)
{
mSamplesPerSymbolListener = listener;
}
/**
* Registers the listener to receive decoded QPSK symbols
*/
public void setComplexSymbolListener(Listener<Complex> listener)
{
mComplexSymbolListener = listener;
}
/**
* Registers the listener to receive PLL error values
*/
public void setPLLErrorListener(Listener<Double> listener)
{
mPLLErrorListener = listener;
}
/**
* Registers the listener to receive PLL error values
*/
public void setPLLFrequencyListener(Listener<Double> listener)
{
mPLLFrequencyListener = listener;
}
}

172
src/main/java/io/github/dsheirer/dsp/psk/DQPSKDecisionDirectedSymbolEvaluator.java
View File

@@ -1,172 +0,0 @@
/*******************************************************************************
* sdr-trunk
* Copyright (C) 2014-2018 Dennis Sheirer
*
* 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 the Free Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with this program.
* If not, see <http://www.gnu.org/licenses/>
*
******************************************************************************/
package io.github.dsheirer.dsp.psk;
import io.github.dsheirer.dsp.symbol.Dibit;
import io.github.dsheirer.sample.complex.Complex;
import org.apache.commons.math3.util.FastMath;
public class DQPSKDecisionDirectedSymbolEvaluator implements IPSKSymbolEvaluator<Dibit>
{
private static final Complex ROTATE_FROM_PLUS_135 = Complex.fromAngle(-3.0 * FastMath.PI / 4.0);
private static final Complex ROTATE_FROM_PLUS_45 = Complex.fromAngle(-1.0 * FastMath.PI / 4.0);
private static final Complex ROTATE_FROM_MINUS_45 = Complex.fromAngle(1.0 * FastMath.PI / 4.0);
private static final Complex ROTATE_FROM_MINUS_135 = Complex.fromAngle(3.0 * FastMath.PI / 4.0);
private Complex mEvaluationSymbol = new Complex(0, 0);
private float mPhaseError = 0.0f;
private float mTimingError = 0.0f;
private float mTimingErrorPolarity = 1.0f;
private Dibit mSymbolDecision = Dibit.D00_PLUS_1;
/**
* Differential QPSK Decision-directed symbol phase and timing error detector and symbol decision slicer.
*
* Symbol decision is based on the closest reference quadrant for the sampled symbol.
*
* Phase and timing error are calculated as the angular distance of the sampled symbol from the reference
* symbol. Timing error is further corrected to compensate for clock-wise or counter-clock-wise vector rotation
* relative to the immediately preceding symbol.
*/
public DQPSKDecisionDirectedSymbolEvaluator()
{
}
/**
* Sets the preceding and current symbols to be evaluated for phase and timing errors and to determine the
* transmitted symbol relative to the closest reference symbol. After invoking this method, you can access the
* phase and timing errors and the symbol decision via their respective accessor methods.
*
* Phase and timing error values are calculated by first determining the symbol and then calculating the phase
* and timing errors relative to the reference symbol. The timing error is corrected with the appropriate sign
* relative to the angular vector rotation so that the error value indicates the correct error direction.
*
* @param preceding differential-decoded sample/symbol used to detect rotation - does NOT need to be interpolated
* since it's only a reference
* @param current symbol to be evaluated - interpolated
*/
public void setSymbol(Complex preceding, Complex current)
{
mEvaluationSymbol.setValues(current);
if(mEvaluationSymbol.quadrature() > 0.0f)
{
if(mEvaluationSymbol.inphase() > 0.0f)
{
mSymbolDecision = Dibit.D00_PLUS_1;
mTimingErrorPolarity = (preceding.quadrature() > current.quadrature() ? 1.0f : -1.0f);
mEvaluationSymbol.multiply(ROTATE_FROM_PLUS_45);
}
else
{
mSymbolDecision = Dibit.D01_PLUS_3;
mTimingErrorPolarity = (preceding.quadrature() < current.quadrature() ? 1.0f : -1.0f);
mEvaluationSymbol.multiply(ROTATE_FROM_PLUS_135);
}
}
else
{
if(mEvaluationSymbol.inphase() > 0.0f)
{
mSymbolDecision = Dibit.D10_MINUS_1;
mTimingErrorPolarity = (preceding.quadrature() > current.quadrature() ? 1.0f : -1.0f);
mEvaluationSymbol.multiply(ROTATE_FROM_MINUS_45);
}
else
{
mSymbolDecision = Dibit.D11_MINUS_3;
mTimingErrorPolarity = (preceding.quadrature() < current.quadrature() ? 1.0f : -1.0f);
mEvaluationSymbol.multiply(ROTATE_FROM_MINUS_135);
}
}
//Since we've rotated the error symbol back to 0 radians, the quadrature value closely approximates the
//arctan of the error angle relative to 0 radians and this provides our error value
float errorNormalized = normalize(mEvaluationSymbol.quadrature(), 0.3f);
mPhaseError = -errorNormalized;
//Timing error is the same as phase error with the sign corrected according to the vector's angular rotation
mTimingError = errorNormalized * mTimingErrorPolarity;
}
/**
* Constrains value to the range of ( -maximum <> maximum )
*/
private static float clip(float value, float maximum)
{
if(value > maximum)
{
return maximum;
}
else if(value < -maximum)
{
return -maximum;
}
return value;
}
/**
* Constrains timing error to +/- the maximum value and corrects any
* floating point invalid numbers
*/
private float normalize(float error, float maximum)
{
if(Float.isNaN(error))
{
return 0.0f;
}
else
{
return clip(error, maximum);
}
}
/**
* Phase error of the symbol relative to the nearest reference symbol.
*
* @return phase error in radians of distance from the reference symbol.
*/
@Override
public float getPhaseError()
{
return mPhaseError;
}
/**
* Timing error of the symbol relative to the nearest reference symbol.
*
* @return timing error in radians of angular distance from the reference symbol recognizing that the symbol
* originates at zero radians and rotates toward the intended reference symbol, therefore the error value indicates
* if the symbol was sampled early (-) or late (+) relative to the reference symbol.
*/
@Override
public float getTimingError()
{
return mTimingError;
}
/**
* Reference symbol that is closest to the transmitted/sampled symbol.
*/
@Override
public Dibit getSymbolDecision()
{
return mSymbolDecision;
}
}

152
src/main/java/io/github/dsheirer/dsp/psk/DQPSKGardnerDemodulatorInstrumented.java
View File

@@ -1,152 +0,0 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2022 Dennis Sheirer
*
* 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
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.dsp.psk;
import io.github.dsheirer.dsp.psk.pll.CostasLoop;
import io.github.dsheirer.dsp.psk.pll.IPhaseLockedLoop;
import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.complex.Complex;
import io.github.dsheirer.sample.complex.ComplexSamples;
import org.apache.commons.math3.util.FastMath;
public class DQPSKGardnerDemodulatorInstrumented extends DQPSKGardnerDemodulator
{
private Listener<SymbolDecisionData> mSymbolDecisionDataListener;
private Listener<Double> mSamplesPerSymbolListener;
private Listener<Complex> mComplexSymbolListener;
private Listener<Double> mPLLErrorListener;
private Listener<Double> mPLLFrequencyListener;
private Listener<ComplexSamples> mFilteredGainAppliedComplexBufferListener;
private double mSampleRate;
/**
* Implements a Differential QPSK demodulator using a Costas Loop (PLL) and a Gardner timing error detector.
*
* This decoder is optimized for P25 Linear Simulcast Modulation (LSM).
*
* @param phaseLockedLoop for tracking carrier frequency error
* @param interpolatingSampleBuffer to hold samples for interpolating a symbol
*/
public DQPSKGardnerDemodulatorInstrumented(IPhaseLockedLoop phaseLockedLoop,
InterpolatingSampleBuffer interpolatingSampleBuffer,
double sampleRate)
{
super(phaseLockedLoop, interpolatingSampleBuffer);
mSampleRate = sampleRate;
}
@Override
public void receive(ComplexSamples complexSamples)
{
if(mFilteredGainAppliedComplexBufferListener != null)
{
mFilteredGainAppliedComplexBufferListener.receive(complexSamples);
}
super.receive(complexSamples);
}
/**
* Overrides the parent class symbol calculation to capture eye diagram data
*/
protected void calculateSymbol()
{
//Eye diagram listener
if(mSymbolDecisionDataListener != null)
{
mSymbolDecisionDataListener.receive(
((InterpolatingSampleBufferInstrumented)getInterpolatingSampleBuffer()).getSymbolDecisionData());
}
super.calculateSymbol();
if(mSamplesPerSymbolListener != null)
{
mSamplesPerSymbolListener.receive((double)getInterpolatingSampleBuffer().getSamplingPoint());
}
//Send to an external constellation symbol listener when registered
if(mComplexSymbolListener != null)
{
mComplexSymbolListener.receive(mCurrentSymbol);
}
if(mPLLErrorListener != null)
{
mPLLErrorListener.receive((double)mSymbolEvaluator.getPhaseError());
}
if(mPLLFrequencyListener != null)
{
double loopFrequency = ((CostasLoop)getPLL()).getLoopFrequency();
loopFrequency *= mSampleRate / (2.0 * FastMath.PI);
mPLLFrequencyListener.receive(loopFrequency);
}
}
/**
* Registers a listener to receive symbol decision data to produce an eye diagram.
*/
public void setSymbolDecisionDataListener(Listener<SymbolDecisionData> listener)
{
mSymbolDecisionDataListener = listener;
}
/**
* Registers the listener to receive PLL error values
*/
public void setSamplesPerSymbolListener(Listener<Double> listener)
{
mSamplesPerSymbolListener = listener;
}
/**
* Registers the listener to receive decoded QPSK symbols
*/
public void setComplexSymbolListener(Listener<Complex> listener)
{
mComplexSymbolListener = listener;
}
/**
* Registers the listener to receive PLL error values
*/
public void setPLLErrorListener(Listener<Double> listener)
{
mPLLErrorListener = listener;
}
/**
* Registers the listener to receive PLL error values
*/
public void setPLLFrequencyListener(Listener<Double> listener)
{
mPLLFrequencyListener = listener;
}
/**
* Registers the listener to receive complex sample buffers that have been filtered with automatic gain control applied
*/
public void setFilteredGainAppliedComplexBufferListener(Listener<ComplexSamples> listener)
{
mFilteredGainAppliedComplexBufferListener = listener;
}
}

83
src/main/java/io/github/dsheirer/dsp/psk/GardnerDetector.java
View File

@@ -1,83 +0,0 @@
/*******************************************************************************
* sdr-trunk
* Copyright (C) 2014-2018 Dennis Sheirer
*
* 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 the Free Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with this program.
* If not, see <http://www.gnu.org/licenses/>
*
******************************************************************************/
package io.github.dsheirer.dsp.psk;
import io.github.dsheirer.sample.complex.Complex;
import org.apache.commons.math3.util.FastMath;
public class GardnerDetector
{
private float mErrorInphase;
private float mErrorQuadrature;
private float mError;
/**
* Gardner detector for recovering symbol timing error.
*/
public GardnerDetector()
{
}
/**
* Calculates the symbol timing error by evaluating the previous, middle and current symbol instants.
*
* @param previous symbol
* @param middle symbol (ie midway between the previous and current)
* @param current symbol
* @return symbol timing error
*/
public float getError(Complex previous, Complex middle, Complex current)
{
mErrorInphase = (FastMath.abs(previous.inphase()) - FastMath.abs(current.inphase())) * FastMath.abs(middle.inphase());
mErrorQuadrature = (FastMath.abs(previous.quadrature()) - FastMath.abs(current.quadrature())) * FastMath.abs(middle.quadrature());
mError = normalize(mErrorInphase + mErrorQuadrature, 1.0f);
return mError;
}
/**
* Constrains timing error to +/- the maximum value and corrects any floating point invalid numbers
*/
public static float normalize(float error, float maximum)
{
if(Float.isNaN(error))
{
return 0.0f;
}
else
{
return clip(error, maximum);
}
}
/**
* Constrains value to the range of ( -maximum <> maximum )
*/
public static float clip(float value, float maximum)
{
if(value > maximum)
{
return maximum;
}
else if(value < -maximum)
{
return -maximum;
}
return value;
}
}

29
src/main/java/io/github/dsheirer/dsp/psk/IQPSKSymbolDecoder.java
View File

@@ -1,29 +0,0 @@
/*******************************************************************************
* sdr-trunk
* Copyright (C) 2014-2018 Dennis Sheirer
*
* 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 the Free Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with this program.
* If not, see <http://www.gnu.org/licenses/>
*
******************************************************************************/
package io.github.dsheirer.dsp.psk;
import io.github.dsheirer.dsp.symbol.Dibit;
import io.github.dsheirer.sample.complex.Complex;
public interface IQPSKSymbolDecoder
{
/**
* Decodes the symbol and converts it into a Dibit
* @param symbol to decode
* @return decoded dibit
*/
Dibit decode(Complex symbol);
}

28
src/main/java/io/github/dsheirer/dsp/psk/ISymbolPhaseErrorCalculator.java
View File

@@ -1,28 +0,0 @@
/*******************************************************************************
* sdr-trunk
* Copyright (C) 2014-2018 Dennis Sheirer
*
* 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 the Free Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with this program.
* If not, see <http://www.gnu.org/licenses/>
*
******************************************************************************/
package io.github.dsheirer.dsp.psk;
import io.github.dsheirer.sample.complex.Complex;
public interface ISymbolPhaseErrorCalculator
{
/**
* Calculates the phase error of the symbol relative to an alignment for the constellation
* @param symbol to calculate error
* @return error value
*/
float getPhaseError(Complex symbol);
}

80
src/main/java/io/github/dsheirer/dsp/psk/InterpolatingSampleBufferInstrumented.java
View File

@@ -1,80 +0,0 @@
/*
*
* * ******************************************************************************
* * Copyright (C) 2014-2019 Dennis Sheirer
* *
* * 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
* * the Free Software Foundation, either version 3 of the License, or
* * (at your option) any later version.
* *
* * This program is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* * GNU General Public License for more details.
* *
* * You should have received a copy of the GNU General Public License
* * along with this program. If not, see <http://www.gnu.org/licenses/>
* * *****************************************************************************
*
*
*/
package io.github.dsheirer.dsp.psk;
import io.github.dsheirer.sample.complex.Complex;
import io.github.dsheirer.sample.complex.ComplexSampleListener;
import org.apache.commons.math3.util.FastMath;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class InterpolatingSampleBufferInstrumented extends InterpolatingSampleBuffer
{
private final static Logger mLog = LoggerFactory.getLogger(InterpolatingSampleBufferInstrumented.class);
private SymbolDecisionData mSymbolDecisionData;
private ComplexSampleListener mSampleListener;
private int mBufferLength;
public InterpolatingSampleBufferInstrumented(float samplesPerSymbol, float symbolTimingGain)
{
super(samplesPerSymbol, symbolTimingGain);
mBufferLength = (int) FastMath.ceil(samplesPerSymbol);
mSymbolDecisionData = new SymbolDecisionData(mBufferLength);
}
public void receive(Complex sample)
{
super.receive(sample);
mSymbolDecisionData.receive(sample);
if(mSampleListener != null)
{
mSampleListener.receive(sample.inphase(), sample.quadrature());
}
}
/**
* Contents of the interpolating buffer and the current buffer index and symbol decision offset. This data can
* be used to support an external eye-diagram chart.
* @return symbol decision data.
*/
public SymbolDecisionData getSymbolDecisionData()
{
for(int x = mDelayLinePointer; x < mDelayLinePointer + mBufferLength; x++)
{
mSymbolDecisionData.receive(mDelayLineInphase[x], mDelayLineQuadrature[x]);
}
mSymbolDecisionData.setSamplingPoint(getSamplingPoint());
return mSymbolDecisionData;
}
/**
* Sets the listener to receive samples being sent to this buffer. Note: these samples have
* already been corrected by the PLL, so this provides an ideal tap point for PLL corrected samples.
* @param listener to receive samples.
*/
public void setSampleListener(ComplexSampleListener listener)
{
mSampleListener = listener;
}
}

28
src/main/java/io/github/dsheirer/dsp/psk/LSMConstellationDecoder.java
View File

@@ -1,28 +0,0 @@
/*******************************************************************************
* sdr-trunk
* Copyright (C) 2014-2018 Dennis Sheirer
*
* 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 the Free Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with this program.
* If not, see <http://www.gnu.org/licenses/>
*
******************************************************************************/
package io.github.dsheirer.dsp.psk;
import io.github.dsheirer.dsp.symbol.Dibit;
import io.github.dsheirer.sample.complex.Complex;
public class LSMConstellationDecoder implements IQPSKSymbolDecoder
{
@Override
public Dibit decode(Complex symbol)
{
return null;
}
}

73
src/main/java/io/github/dsheirer/dsp/psk/QPSKStarSlicer.java
View File

@@ -1,73 +0,0 @@
/*******************************************************************************
* sdr-trunk
* Copyright (C) 2014-2018 Dennis Sheirer
*
* 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 the Free Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with this program.
* If not, see <http://www.gnu.org/licenses/>
*
******************************************************************************/
package io.github.dsheirer.dsp.psk;
import io.github.dsheirer.dsp.symbol.Dibit;
import io.github.dsheirer.sample.Broadcaster;
import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.complex.Complex;
public class QPSKStarSlicer implements IQPSKSymbolDecoder, Listener<Complex>
{
private Broadcaster<Dibit> mBroadcaster = new Broadcaster<Dibit>();
/**
* Slices a Complex sample representing a phase shifted symbol according to the following constellation pattern:
*
* 00 +3 | 01 +1
* ------|------
* 10 -1 | 11 -1
*/
public QPSKStarSlicer()
{
}
public void dispose()
{
mBroadcaster.dispose();
mBroadcaster = null;
}
public void addListener(Listener<Dibit> listener)
{
mBroadcaster.addListener(listener);
}
public void removeListener(Listener<Dibit> listener)
{
mBroadcaster.removeListener(listener);
}
@Override
public void receive(Complex sample)
{
mBroadcaster.broadcast(decode(sample));
}
@Override
public Dibit decode(Complex sample)
{
if(sample.inphase() > 0)
{
return sample.quadrature() > 0 ? Dibit.D00_PLUS_1 : Dibit.D10_MINUS_1;
}
else
{
return sample.quadrature() > 0 ? Dibit.D01_PLUS_3 : Dibit.D11_MINUS_3;
}
}
}

91
src/main/java/io/github/dsheirer/dsp/psk/QPSKSymbolDecoder.java
View File

@@ -1,91 +0,0 @@
/*******************************************************************************
* sdr-trunk
* Copyright (C) 2014-2018 Dennis Sheirer
*
* 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 the Free Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with this program.
* If not, see <http://www.gnu.org/licenses/>
*
******************************************************************************/
package io.github.dsheirer.dsp.psk;
import io.github.dsheirer.dsp.symbol.Dibit;
import io.github.dsheirer.sample.Broadcaster;
import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.complex.Complex;
import org.apache.commons.math3.util.FastMath;
public class QPSKSymbolDecoder implements Listener<Complex>, IQPSKSymbolDecoder
{
private Broadcaster<Dibit> mBroadcaster = new Broadcaster<Dibit>();
/**
* Slices a ComplexSample representing a phase shifted symbol according to
* the following constellation pattern:
*
* \ 00 /
* \ /
* 01 \/ 10
* /\
* / \
* / 11 \
*/
public QPSKSymbolDecoder()
{
}
public void dispose()
{
mBroadcaster.dispose();
mBroadcaster = null;
}
public void addListener( Listener<Dibit> listener )
{
mBroadcaster.addListener( listener );
}
public void removeListener( Listener<Dibit> listener )
{
mBroadcaster.removeListener( listener );
}
@Override
public void receive( Complex complex )
{
mBroadcaster.broadcast( decode( complex ) );
}
public Dibit decode(Complex complex )
{
if( FastMath.abs( complex.inphase() ) > FastMath.abs( complex.quadrature() ) )
{
if( complex.inphase() > 0 )
{
return Dibit.D10_MINUS_1;
}
else
{
return Dibit.D01_PLUS_3;
}
}
else
{
if( complex.quadrature() > 0 )
{
return Dibit.D00_PLUS_1;
}
else
{
return Dibit.D11_MINUS_3;
}
}
}
}

58
src/main/java/io/github/dsheirer/dsp/psk/QPSKSymbolPhaseErrorCalculator.java
View File

@@ -1,58 +0,0 @@
/*******************************************************************************
* sdr-trunk
* Copyright (C) 2014-2018 Dennis Sheirer
*
* 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 the Free Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with this program.
* If not, see <http://www.gnu.org/licenses/>
*
******************************************************************************/
package io.github.dsheirer.dsp.psk;
import io.github.dsheirer.sample.complex.Complex;
import org.apache.commons.math3.util.FastMath;
/**
* Calculates the phase error for a QPSK polar-orientation constellation
*/
public class QPSKSymbolPhaseErrorCalculator implements ISymbolPhaseErrorCalculator
{
private float mPhaseError;
@Override
public float getPhaseError(Complex symbol)
{
mPhaseError = 0.0f;
if(FastMath.abs(symbol.inphase()) > FastMath.abs(symbol.quadrature()))
{
if(symbol.inphase() > 0)
{
mPhaseError = -symbol.quadrature();
}
else
{
mPhaseError = symbol.quadrature();
}
}
else
{
if(symbol.quadrature() > 0)
{
mPhaseError = symbol.inphase();
}
else
{
mPhaseError = -symbol.inphase();
}
}
return mPhaseError;
}
}

115
src/main/java/io/github/dsheirer/dsp/psk/SymbolDecisionData.java
View File

@@ -1,115 +0,0 @@
/*
*
* * ******************************************************************************
* * Copyright (C) 2014-2019 Dennis Sheirer
* *
* * 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
* * the Free Software Foundation, either version 3 of the License, or
* * (at your option) any later version.
* *
* * This program is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* * GNU General Public License for more details.
* *
* * You should have received a copy of the GNU General Public License
* * along with this program. If not, see <http://www.gnu.org/licenses/>
* * *****************************************************************************
*
*
*/
package io.github.dsheirer.dsp.psk;
import io.github.dsheirer.buffer.ComplexCircularBuffer;
import io.github.dsheirer.sample.complex.Complex;
import org.apache.commons.math3.util.FastMath;
public class SymbolDecisionData
{
//45 degrees rotation to orient the symbol to a polar axis to make error calculation easy/efficient
public static final Complex DIFFERENTIAL_OFFSET = Complex.fromAngle(FastMath.PI / 4.0d);
private ComplexCircularBuffer mBuffer;
private float mSamplingPoint;
private float mSamplesPerSymbol;
/**
* Circular buffer for capturing two symbols worth of sample data for use in instrumentation.
* @param samplesPerSymbol to size the buffer
*/
public SymbolDecisionData(float samplesPerSymbol)
{
mSamplesPerSymbol = samplesPerSymbol;
mBuffer = new ComplexCircularBuffer(8);
}
/**
* Stores the complex sample in the buffer
*/
public void receive(float inphase, float quadrature)
{
mBuffer.put(new Complex(inphase, quadrature));
}
/**
* Stores the complex sample in the buffer
*/
public void receive(Complex complex)
{
mBuffer.put(complex.copy());
}
/**
* Sets the fractional sampling point for the current symbol to use in interpolating the current symbol.
*/
public void setSamplingPoint(float samplingPoint)
{
mSamplingPoint = samplingPoint;
}
/**
* Fractional sampling point
*/
public float getSamplingPoint()
{
return mSamplingPoint;
}
/**
* Raw samples
*/
public Complex[] getSamples()
{
return mBuffer.getAll();
}
public Complex[] getSamples(int length)
{
return mBuffer.get(length);
}
/**
* Array of (FM) demodulated samples representing the current symbol where each current sample is demodulated against
* the previous symbol's sample to produce the differential demodulated sample. Samples are in time order.
*
* Note: differential decoding is on an integral samples-per-symbol basis and does not use fractional interpolation.
*/
public Complex[] getDemodulated()
{
Complex[] samples = mBuffer.getAll();
int length = samples.length / 2;
Complex[] demodulated = new Complex[length];
for(int x = 0; x < samples.length / 2; x++)
{
Complex copy = samples[length + x].copy();
copy.multiply(samples[x].conjugate());
demodulated[x] = copy;
}
return demodulated;
}
}

37
src/main/java/io/github/dsheirer/dsp/psk/SymbolInversion.java
View File

@@ -1,37 +0,0 @@
/*******************************************************************************
* sdr-trunk
* Copyright (C) 2014-2018 Dennis Sheirer
*
* 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 the Free Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with this program.
* If not, see <http://www.gnu.org/licenses/>
*
******************************************************************************/
package io.github.dsheirer.dsp.psk;
import org.apache.commons.math3.util.FastMath;
public enum SymbolInversion
{
DEGREES_90_PLUS(FastMath.PI / 2.0),
DEGREES_90_MINUS(FastMath.PI / -2.0),
DEGREES_180(FastMath.PI);
private double mAngleRadians;
SymbolInversion(double angleRadians)
{
mAngleRadians = angleRadians;
}
public double getError()
{
return mAngleRadians;
}
}

20
src/main/java/io/github/dsheirer/dsp/psk/demod/DifferentialDemodulatorFactory.java
View File

@@ -22,34 +22,30 @@ package io.github.dsheirer.dsp.psk.demod;
import io.github.dsheirer.vector.calibrate.CalibrationManager;
import io.github.dsheirer.vector.calibrate.CalibrationType;
import io.github.dsheirer.vector.calibrate.Implementation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Factory for creating PSK differential demodulators
*/
public class DifferentialDemodulatorFactory
{
private static final Logger mLog = LoggerFactory.getLogger(DifferentialDemodulatorFactory.class);
/**
* Creates the optimal demodulator using calibration data to select the optimal implementation from scalar and
* vector options, or defaults to the scalar implementation if the calibration wasn't executed.
* Creates the optimal float output demodulator using calibration data to select the optimal implementation from
* scalar and vector options, or defaults to the scalar implementation if the calibration wasn't executed.
* @param sampleRate in Hertz
* @param symbolRate in Hertz
* @return demodulator instance
*/
public static DifferentialDemodulator getDemodulator(double sampleRate, int symbolRate)
public static DifferentialDemodulatorFloat getFloatDemodulator(double sampleRate, int symbolRate)
{
Implementation implementation = CalibrationManager.getInstance().getImplementation(CalibrationType.DIFFERENTIAL_DEMODULATOR);
return switch(implementation)
{
case VECTOR_SIMD_64 -> new DifferentialDemodulatorVector64(sampleRate, symbolRate);
case VECTOR_SIMD_128 -> new DifferentialDemodulatorVector128(sampleRate, symbolRate);
case VECTOR_SIMD_256 -> new DifferentialDemodulatorVector256(sampleRate, symbolRate);
case VECTOR_SIMD_512 -> new DifferentialDemodulatorVector512(sampleRate, symbolRate);
default -> new DifferentialDemodulatorScalar(sampleRate, symbolRate); //Includes SCALAR case
case VECTOR_SIMD_64 -> new DifferentialDemodulatorFloatVector64(sampleRate, symbolRate);
case VECTOR_SIMD_128 -> new DifferentialDemodulatorFloatVector128(sampleRate, symbolRate);
case VECTOR_SIMD_256 -> new DifferentialDemodulatorFloatVector256(sampleRate, symbolRate);
case VECTOR_SIMD_512 -> new DifferentialDemodulatorFloatVector512(sampleRate, symbolRate);
default -> new DifferentialDemodulatorFloatScalar(sampleRate, symbolRate); //Includes SCALAR case
};
}
}

10
src/main/java/io/github/dsheirer/dsp/psk/demod/DifferentialDemodulator.java → src/main/java/io/github/dsheirer/dsp/psk/demod/DifferentialDemodulatorFloat.java
View File

@@ -26,7 +26,7 @@ import io.github.dsheirer.dsp.fm.IDemodulator;
/**
* Differential demodulator base class
*/
public abstract class DifferentialDemodulator implements IDemodulator
public abstract class DifferentialDemodulatorFloat implements IDemodulator
{
private int mSymbolRate;
private float mSampleRate;
@@ -37,14 +37,14 @@ public abstract class DifferentialDemodulator implements IDemodulator
protected int mBufferOverlap;
protected int mInterpolationOffset;
protected final Interpolator mInterpolator = InterpolatorFactory.getInterpolator();
private DifferentialDemodulatorScalar mScalar;
private DifferentialDemodulatorFloatScalar mScalar;
/**
* Constructor
* @param sampleRate in Hertz
* @param symbolRate symbols per second
*/
public DifferentialDemodulator(double sampleRate, int symbolRate)
public DifferentialDemodulatorFloat(double sampleRate, int symbolRate)
{
mSampleRate = (float) sampleRate;
mSymbolRate = symbolRate;
@@ -64,11 +64,11 @@ public abstract class DifferentialDemodulator implements IDemodulator
* Scalar implementation for fallback when the sample buffer size is not compatible with the vector implementation.
* @return scalar implementation lazy instantiated when needed.
*/
protected DifferentialDemodulatorScalar getScalarImplementation()
protected DifferentialDemodulatorFloatScalar getScalarImplementation()
{
if(mScalar == null)
{
mScalar = new DifferentialDemodulatorScalar(mSampleRate, mSymbolRate);
mScalar = new DifferentialDemodulatorFloatScalar(mSampleRate, mSymbolRate);
}
return mScalar;

6
src/main/java/io/github/dsheirer/dsp/psk/demod/DifferentialDemodulatorScalar.java → src/main/java/io/github/dsheirer/dsp/psk/demod/DifferentialDemodulatorFloatScalar.java
View File

@@ -26,16 +26,16 @@ import org.slf4j.LoggerFactory;
/**
* Differential demodulator that uses scalar calculations for demodulating the sample stream.
*/
public class DifferentialDemodulatorScalar extends DifferentialDemodulator
public class DifferentialDemodulatorFloatScalar extends DifferentialDemodulatorFloat
{
private static final Logger LOGGER = LoggerFactory.getLogger(DifferentialDemodulatorScalar.class);
private static final Logger LOGGER = LoggerFactory.getLogger(DifferentialDemodulatorFloatScalar.class);
/**
* Constructor
*
* @param symbolRate symbols per second
*/
public DifferentialDemodulatorScalar(double sampleRate, int symbolRate)
public DifferentialDemodulatorFloatScalar(double sampleRate, int symbolRate)
{
super(sampleRate, symbolRate);
}

6
src/main/java/io/github/dsheirer/dsp/psk/demod/DifferentialDemodulatorVector128.java → src/main/java/io/github/dsheirer/dsp/psk/demod/DifferentialDemodulatorFloatVector128.java
View File

@@ -29,9 +29,9 @@ import org.slf4j.LoggerFactory;
/**
* Differential demodulator that uses Vector SIMD 128 calculations for demodulating the sample stream.
*/
public class DifferentialDemodulatorVector128 extends DifferentialDemodulator
public class DifferentialDemodulatorFloatVector128 extends DifferentialDemodulatorFloat
{
private static final Logger LOGGER = LoggerFactory.getLogger(DifferentialDemodulatorVector128.class);
private static final Logger LOGGER = LoggerFactory.getLogger(DifferentialDemodulatorFloatVector128.class);
private static final VectorSpecies<Float> VECTOR_SPECIES = FloatVector.SPECIES_128;
/**
@@ -40,7 +40,7 @@ public class DifferentialDemodulatorVector128 extends DifferentialDemodulator
* @param sampleRate in Hertz
* @param symbolRate symbols per second
*/
public DifferentialDemodulatorVector128(double sampleRate, int symbolRate)
public DifferentialDemodulatorFloatVector128(double sampleRate, int symbolRate)
{
super(sampleRate, symbolRate);
}

4
src/main/java/io/github/dsheirer/dsp/psk/demod/DifferentialDemodulatorVector256.java → src/main/java/io/github/dsheirer/dsp/psk/demod/DifferentialDemodulatorFloatVector256.java
View File

@@ -27,7 +27,7 @@ import jdk.incubator.vector.VectorSpecies;
/**
* Differential demodulator that uses Vector SIMD calculations for demodulating the sample stream.
*/
public class DifferentialDemodulatorVector256 extends DifferentialDemodulator
public class DifferentialDemodulatorFloatVector256 extends DifferentialDemodulatorFloat
{
private static final VectorSpecies<Float> VECTOR_SPECIES = FloatVector.SPECIES_256;
@@ -37,7 +37,7 @@ public class DifferentialDemodulatorVector256 extends DifferentialDemodulator
* @param sampleRate in Hertz
* @param symbolRate symbols per second
*/
public DifferentialDemodulatorVector256(double sampleRate, int symbolRate)
public DifferentialDemodulatorFloatVector256(double sampleRate, int symbolRate)
{
super(sampleRate, symbolRate);
}

6
src/main/java/io/github/dsheirer/dsp/psk/demod/DifferentialDemodulatorVector512.java → src/main/java/io/github/dsheirer/dsp/psk/demod/DifferentialDemodulatorFloatVector512.java
View File

@@ -29,9 +29,9 @@ import org.slf4j.LoggerFactory;
/**
* Differential demodulator that uses Vector SIMD 512 calculations for demodulating the sample stream.
*/
public class DifferentialDemodulatorVector512 extends DifferentialDemodulator
public class DifferentialDemodulatorFloatVector512 extends DifferentialDemodulatorFloat
{
private static final Logger LOGGER = LoggerFactory.getLogger(DifferentialDemodulatorVector512.class);
private static final Logger LOGGER = LoggerFactory.getLogger(DifferentialDemodulatorFloatVector512.class);
private static final VectorSpecies<Float> VECTOR_SPECIES = FloatVector.SPECIES_512;
/**
@@ -39,7 +39,7 @@ public class DifferentialDemodulatorVector512 extends DifferentialDemodulator
*
* @param symbolRate symbols per second
*/
public DifferentialDemodulatorVector512(double sampleRate, int symbolRate)
public DifferentialDemodulatorFloatVector512(double sampleRate, int symbolRate)
{
super(sampleRate, symbolRate);
}

6
src/main/java/io/github/dsheirer/dsp/psk/demod/DifferentialDemodulatorVector64.java → src/main/java/io/github/dsheirer/dsp/psk/demod/DifferentialDemodulatorFloatVector64.java
View File

@@ -29,9 +29,9 @@ import org.slf4j.LoggerFactory;
/**
* Differential demodulator that uses Vector SIMD 64 calculations for demodulating the sample stream.
*/
public class DifferentialDemodulatorVector64 extends DifferentialDemodulator
public class DifferentialDemodulatorFloatVector64 extends DifferentialDemodulatorFloat
{
private static final Logger LOGGER = LoggerFactory.getLogger(DifferentialDemodulatorVector64.class);
private static final Logger LOGGER = LoggerFactory.getLogger(DifferentialDemodulatorFloatVector64.class);
private static final VectorSpecies<Float> VECTOR_SPECIES = FloatVector.SPECIES_64;
/**
@@ -40,7 +40,7 @@ public class DifferentialDemodulatorVector64 extends DifferentialDemodulator
* @param sampleRate in Hertz
* @param symbolRate symbols per second
*/
public DifferentialDemodulatorVector64(double sampleRate, int symbolRate)
public DifferentialDemodulatorFloatVector64(double sampleRate, int symbolRate)
{
super(sampleRate, symbolRate);
}

125
src/main/java/io/github/dsheirer/dsp/psk/pll/AdaptivePLLBandwidthMonitor.java
View File

@@ -1,125 +0,0 @@
/*
*
* * ******************************************************************************
* * Copyright (C) 2014-2020 Dennis Sheirer
* *
* * 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
* * the Free Software Foundation, either version 3 of the License, or
* * (at your option) any later version.
* *
* * This program is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* * GNU General Public License for more details.
* *
* * You should have received a copy of the GNU General Public License
* * along with this program. If not, see <http://www.gnu.org/licenses/>
* * *****************************************************************************
*
*
*/
package io.github.dsheirer.dsp.psk.pll;
import io.github.dsheirer.dsp.symbol.ISyncDetectListener;
import io.github.dsheirer.module.decode.FeedbackDecoder;
import io.github.dsheirer.source.SourceEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Monitors decode sync events to adaptively control PLL loop gain.
*/
public class AdaptivePLLBandwidthMonitor implements ISyncDetectListener, IFrequencyErrorProcessor
{
private final static Logger mLog = LoggerFactory.getLogger(AdaptivePLLBandwidthMonitor.class);
private static final int MAX_SYNC_COUNT = PLLBandwidth.BW_200.getRangeEnd();
private CostasLoop mCostasLoop;
private FeedbackDecoder mFeedbackDecoder;
private PLLBandwidth mPLLBandwidth = PLLBandwidth.BW_400;
private int mSyncCount;
/**
* Constructs an adaptive monitor to monitor the sync state of a decoder and adjust the gain
* level of the costas loop accordingly.
*
* @param costasLoop to receive adaptive gain updates.
* @param feedbackDecoder to rebroadcast frequency error source events
*/
public AdaptivePLLBandwidthMonitor(CostasLoop costasLoop, FeedbackDecoder feedbackDecoder)
{
mCostasLoop = costasLoop;
mCostasLoop.setPLLBandwidth(mPLLBandwidth);
mCostasLoop.setFrequencyErrorProcessor(this);
mFeedbackDecoder = feedbackDecoder;
}
/**
* Sync detection event. Updates the running sync count and updates the PLL gain level.
*/
@Override
public void syncDetected(int bitErrors)
{
mSyncCount++;
update();
}
/**
* Sync loss event. Updates the running sync count and updates the PLL gain level.
*/
@Override
public void syncLost(int bitsProcessed)
{
mSyncCount -= 2;
update();
}
/**
* Updates the gain state for a sync detect or sync loss
*/
private void update()
{
if(mSyncCount < 0)
{
mSyncCount = 0;
return;
}
if(mSyncCount > MAX_SYNC_COUNT)
{
mSyncCount = MAX_SYNC_COUNT;
return;
}
PLLBandwidth gain = PLLBandwidth.fromSyncCount(mSyncCount);
//Only update the costas loop if the gain value changes
if(gain != mPLLBandwidth)
{
mPLLBandwidth = gain;
mCostasLoop.setPLLBandwidth(mPLLBandwidth);
}
}
/**
* Resets the monitor and commands the PLL to use the highest gain level.
*/
public void reset()
{
mSyncCount = 0;
mPLLBandwidth = PLLBandwidth.BW_400;
mCostasLoop.setPLLBandwidth(mPLLBandwidth);
}
@Override
public void processFrequencyError(long frequencyError)
{
//Only rebroadcast the costas loop frequency error if the gain level has progressed above
//a bandwidth of 300, meaning that we have received at least 4 sync events
if(mPLLBandwidth != PLLBandwidth.BW_400 && mPLLBandwidth != PLLBandwidth.BW_300)
{
mFeedbackDecoder.broadcast(SourceEvent.frequencyErrorMeasurement(frequencyError));
}
}
}

1
src/main/java/io/github/dsheirer/dsp/psk/pll/FrequencyCorrectionSyncMonitor.java
View File

@@ -27,6 +27,7 @@ import org.slf4j.LoggerFactory;
/**
* Monitors decode sync events to adaptively control frequency correction broadcasts.
*/
@Deprecated //Remove after P25P2 decoder gets updated
public class FrequencyCorrectionSyncMonitor implements ISyncDetectListener, IFrequencyErrorProcessor
{
private final static Logger mLog = LoggerFactory.getLogger(FrequencyCorrectionSyncMonitor.class);

133
src/main/java/io/github/dsheirer/dsp/psk/pll/QPSKPhaseInversionCalculator.java
View File

@@ -1,133 +0,0 @@
/*
*
* * ******************************************************************************
* * Copyright (C) 2014-2020 Dennis Sheirer
* *
* * 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
* * the Free Software Foundation, either version 3 of the License, or
* * (at your option) any later version.
* *
* * This program is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* * GNU General Public License for more details.
* *
* * You should have received a copy of the GNU General Public License
* * along with this program. If not, see <http://www.gnu.org/licenses/>
* * *****************************************************************************
*
*
*/
package io.github.dsheirer.dsp.psk.pll;
import io.github.dsheirer.dsp.symbol.Dibit;
/**
* Utility for calculating phase inverted sync pattern derivatives for QPSK constellations
*/
public class QPSKPhaseInversionCalculator
{
public static void main(String[] args)
{
//DMR sync patterns
// String[] syncs = {"755FD7DF75F7", "DFF57D75DF5D", "7F7D5DD57DFD", "D5D7F77FD757", "77D55F7DFD77",
// "5D577F7757FF", "F7FDD5DDFD55", "7DFFD5F55D5F", "D7557F5FF7F5", "DD7FF5D757DD"};
//P25 Phase 2 sync pattern
String[] syncs = {"575D57F7FF"};
//P25 Phase 1 sync pattern
// String[] syncs = {"5575F5FF77FF"};
for(String sync: syncs)
{
StringBuilder sbNorm = new StringBuilder();
StringBuilder sbP90 = new StringBuilder();
StringBuilder sbM90 = new StringBuilder();
StringBuilder sb180 = new StringBuilder();
for(char letter: sync.toCharArray())
{
int value;
if(Character.isAlphabetic(letter))
{
value = letter - 55;
}
else
{
value = letter - 48;
}
sbNorm.append(letter);
sbP90.append(rotate(value, Dibit.Rotation.PLUS90));
sbM90.append(rotate(value, Dibit.Rotation.MINUS90));
sb180.append(rotate(value, Dibit.Rotation.INVERT));
}
System.out.println("NORMAL: " + sync);
System.out.println(" +90: " + sbP90);
System.out.println(" -90: " + sbM90);
System.out.println(" 180: " + sb180);
}
}
/**
* Converts the hexadecimal value to an integer, decomposes it into high and low order dibits, rotates the dibits
* in the specified direction, and recombines the rotated dibits into a 4-bit value, returned as a hex character.
* @param value to rotate
* @param direction direction
* @return rotated hex character
*/
public static String rotate(int value, Dibit.Rotation direction)
{
try
{
Dibit dibitHigh = getHighDibit(value);
Dibit dibitLow = getLowDibit(value);
return getHex(dibitHigh.rotate(direction), dibitLow.rotate(direction));
}
catch(Exception e)
{
//ignore
}
return "-";
}
/**
* Combines the bit values from the two dibits and converts the integer value to a hex character
* @param d1 containing the high order bits
* @param d2 containing the low order bits
* @return string hex character representing the value of these dibits combined
*/
public static String getHex(Dibit d1, Dibit d2)
{
int value = d1.getHighValue() + d2.getLowValue();
return Integer.toHexString(value).toUpperCase();
}
/**
* Calculates the dibit that represents the bits in the 0x8 and 0x4 bit positions of the value
* @param value
* @return a dibit
*/
public static Dibit getHighDibit(int value)
{
return Dibit.fromValue((value >> 2) & 3);
}
/**
* Calculates the dibit that represents the bits in the 0x2 and 0x1 bit positions of the value
* @param value
* @return a dibit
*/
public static Dibit getLowDibit(int value)
{
return Dibit.fromValue(value & 3);
}
}

41
src/main/java/io/github/dsheirer/dsp/squelch/PowerMonitor.java
View File

@@ -34,14 +34,14 @@ public class PowerMonitor
private int mPowerLevelBroadcastCount = 0;
private int mPowerLevelBroadcastThreshold;
private Listener<SourceEvent> mSourceEventListener;
private SinglePoleIirFilter mPowerFilter = new SinglePoleIirFilter(0.1f);
private final SinglePoleIirFilter mPowerFilter = new SinglePoleIirFilter(0.1f);
/**
* Constructs an instance
*/
public PowerMonitor()
{
mPowerLevelBroadcastThreshold = 25000; //Based on a default sample rate of 50 kHz
mPowerLevelBroadcastThreshold = 12500; //Based on a default sample rate of 25 kHz
}
/**
@@ -54,36 +54,25 @@ public class PowerMonitor
mPowerLevelBroadcastThreshold = sampleRate / 2;
}
/**
* Processes a complex IQ sample and changes squelch state when the signal power is above or below the
* threshold value.
* @param inphase complex sample component
* @param quadrature complex sample component
*/
public void process(float inphase, float quadrature)
{
mPowerLevelBroadcastCount++;
if(mPowerLevelBroadcastCount > mPowerLevelBroadcastThreshold)
{
mPowerFilter.filter(inphase * inphase + quadrature * quadrature);
}
if(mPowerLevelBroadcastCount > (mPowerLevelBroadcastThreshold + 10))
{
mPowerLevelBroadcastCount = 0;
broadcast(SourceEvent.channelPowerLevel(null, 10.0 * Math.log10(mPowerFilter.getValue())));
}
}
/**
* Processes I&Q complex baseband sample buffers.
*/
public void process(float[] i, float[] q)
{
for(int x = 0; x < i.length; x++)
mPowerLevelBroadcastCount += i.length;
if(mPowerLevelBroadcastCount > mPowerLevelBroadcastThreshold && i.length >= 10)
{
process(i[x], q[x]);
double iSquared, qSquared;
for(int x = 0; x < 10; x++)
{
iSquared = Math.pow(i[x], 2.0f);
qSquared = Math.pow(q[x], 2.0f);
mPowerFilter.filter((float)(iSquared + qSquared));
}
mPowerLevelBroadcastCount -= mPowerLevelBroadcastThreshold;
broadcast(SourceEvent.channelPowerLevel(null, 10.0 * Math.log10(mPowerFilter.getValue())));
}
}

23
src/main/java/io/github/dsheirer/dsp/symbol/Dibit.java
View File

@@ -265,15 +265,24 @@ public enum Dibit
}
}
public static void main(String[] args)
/**
* Number of bit errors between this dibit and the expected dibit argument.
* @param dibit to compare
* @return 0, 1 or 2 bit errors
*/
public int getBitErrorFrom(Dibit dibit)
{
byte a = (byte)0x1B;
int xor = getValue() ^ dibit.getValue();
Dibit d1 = Dibit.parse(a, 0);
Dibit d2 = Dibit.parse(a, 1);
Dibit d3 = Dibit.parse(a, 2);
Dibit d4 = Dibit.parse(a, 3);
if(xor == 0)
{
return 0;
}
else if(xor == 3)
{
return 2;
}
System.out.println("1: " + d1 + " 2:" + d2 + " 3:" + d3 + " 4:" + d4);
return 1;
}
}

260
src/main/java/io/github/dsheirer/dsp/symbol/DibitDelayBuffer.java
View File

@@ -1,260 +0,0 @@
/*
*
* * ******************************************************************************
* * Copyright (C) 2014-2019 Dennis Sheirer
* *
* * 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
* * the Free Software Foundation, either version 3 of the License, or
* * (at your option) any later version.
* *
* * This program is distributed in the hope that it will be useful,
* * but WITHOUT ANY WARRANTY; without even the implied warranty of
* * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* * GNU General Public License for more details.
* *
* * You should have received a copy of the GNU General Public License
* * along with this program. If not, see <http://www.gnu.org/licenses/>
* * *****************************************************************************
*
*
*/
package io.github.dsheirer.dsp.symbol;
import io.github.dsheirer.bits.BitSetFullException;
import io.github.dsheirer.bits.CorrectedBinaryMessage;
import org.apache.commons.lang3.Validate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Circular buffer for storing and accessing dibits.
*/
public class DibitDelayBuffer
{
private final static Logger mLog = LoggerFactory.getLogger(DibitDelayBuffer.class);
protected Dibit[] mBuffer;
protected int mPointer;
/**
* Constructs a dibit delay buffer of the specified length
*/
public DibitDelayBuffer(int length)
{
Validate.isTrue(length > 0, "Dibit buffer length must be greater than 0");
mBuffer = new Dibit[length];
reset();
}
/**
* Resets the buffer and preloads the buffer with all zeros
*/
public void reset()
{
for(int x = 0; x < mBuffer.length; x++)
{
mBuffer[x] = Dibit.D00_PLUS_1;
}
}
/**
* Length of this circular buffer
*/
public int length()
{
return mBuffer.length;
}
/**
* Returns the dibit at the specified index
* @param index to get
* @return dibit at the specified index
*/
public Dibit get(int index)
{
if(index < 0 || index >= mBuffer.length)
{
throw new IllegalArgumentException("Index argument must be between 0 and buffer length [" + mBuffer.length + "]");
}
return mBuffer[index];
}
/**
* Sets the dibit at the specified index
* @param index of the dibit
* @param dibit to load at the specified index
*/
public void set(int index, Dibit dibit)
{
if(index < 0 || index >= mBuffer.length)
{
throw new IllegalArgumentException("Index argument must be between 0 and buffer length [" + mBuffer.length + "]");
}
mBuffer[index] = dibit;
}
/**
* Returns an ordered view of the internal circular buffer contents.
*/
public Dibit[] getBuffer()
{
Dibit[] transferBuffer = new Dibit[mBuffer.length];
int transferBufferPointer = 0;
int bufferPointer = mPointer;
while(transferBufferPointer < transferBuffer.length)
{
transferBuffer[transferBufferPointer++] = mBuffer[bufferPointer++];
if(bufferPointer >= mBuffer.length)
{
bufferPointer = 0;
}
}
return transferBuffer;
}
/**
* Retrieves a view of the buffer from the starting index to the specified length. Note: if the requested
* length exceeds the length of this buffer, the contents will be unwrapped from the circular buffer and repeated.
* @param start of the view where 0 is the first element.
* @param length of the dibit view
* @return an array of dibits
*/
public Dibit[] getBuffer(int start, int length)
{
Dibit[] transferBuffer = new Dibit[length];
int transferBufferPointer = 0;
int bufferPointer = (mPointer + start) % mBuffer.length;
while(transferBufferPointer < transferBuffer.length)
{
transferBuffer[transferBufferPointer++] = mBuffer[bufferPointer++];
if(bufferPointer >= mBuffer.length)
{
bufferPointer = 0;
}
}
return transferBuffer;
}
/**
* Extracts a corrected binary message from the dibit buffer
*
* @param start dibit index where 0 is the oldest dibit and the newest dibit is buffer length - 1
* @param dibitLength number of dibits to include in the message, making the message length = dibitLength * 2
* @return corrected binary message
*/
public CorrectedBinaryMessage getMessage(int start, int dibitLength)
{
CorrectedBinaryMessage message = new CorrectedBinaryMessage(dibitLength * 2);
int dibitCount = 0;
int bufferPointer = (mPointer + start) % mBuffer.length;
try
{
while(dibitCount < dibitLength)
{
Dibit dibit = mBuffer[bufferPointer++];
message.add(dibit.getBit1());
message.add(dibit.getBit2());
dibitCount++;
if(bufferPointer >= mBuffer.length)
{
bufferPointer = 0;
}
}
}
catch(BitSetFullException e)
{
//This shouldn't happen
mLog.error("Bit set full ??", e);
}
return message;
}
/**
* Utility method to view the buffer contents with the dibits decoded as an array of zeros and ones.
*/
public int[] getBufferAsArray()
{
Dibit[] dibits = getBuffer();
int[] bits = new int[dibits.length * 2];
for(int x = 0; x < dibits.length; x++)
{
if(dibits[x].getBit1())
{
bits[x * 2] = 1;
}
if(dibits[x].getBit2())
{
bits[x * 2 + 1] = 1;
}
}
return bits;
}
/**
* Places the dibit into the internal circular buffer, overwriting the oldest dibit.
*/
public void put(Dibit dibit)
{
mBuffer[mPointer++] = dibit;
if(mPointer >= mBuffer.length)
{
mPointer = 0;
}
}
/**
* Places the dibit into the internal circular buffer, overwriting and returning the
* oldest dibit.
*/
public Dibit getAndPut(Dibit dibit)
{
Dibit toReturn = mBuffer[mPointer];
put(dibit);
return toReturn;
}
/**
* Logs the contents of the buffer
*/
public void log()
{
StringBuilder sb = new StringBuilder();
int counter = 0;
int pointer = mPointer;
while(counter < mBuffer.length)
{
sb.append(mBuffer[pointer].getBit1() ? "1" : "0");
sb.append(mBuffer[pointer++].getBit2() ? "1" : "0");
if(pointer >= mBuffer.length)
{
pointer = 0;
}
counter++;
}
mLog.debug("BUFFER: " + sb + " Length:" + mBuffer.length);
}
}

128
src/main/java/io/github/dsheirer/dsp/symbol/DibitDelayLine.java Normal file
View File

@@ -0,0 +1,128 @@
/*
* *****************************************************************************
* Copyright (C) 2014-2025 Dennis Sheirer
*
* 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
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
* ****************************************************************************
*/
package io.github.dsheirer.dsp.symbol;
import java.util.Arrays;
/**
* Implements a circular buffer delay line for dibits.
*/
public class DibitDelayLine
{
protected Dibit[] mDelayLine;
public int mPointer;
/**
* Constructs an instance
* @param length of the delay line in dibits.
*/
public DibitDelayLine(int length)
{
mDelayLine = new Dibit[length];
Arrays.fill(mDelayLine, Dibit.D00_PLUS_1);
}
/**
* Inserts the dibit into the delay line and returns the oldest dibit from the delay line.
* @param dibit to insert
* @return oldest dibit
*/
public Dibit insert(Dibit dibit)
{
Dibit ejected = mDelayLine[mPointer];
mDelayLine[mPointer++] = dibit;
mPointer %= mDelayLine.length;
return ejected;
}
/**
* Overwrites the most recently added dibits in the delay line with the provided sequence. This can be used when
* a sync pattern is detected to overwrite the calculated symbols with the known sync pattern.
* @param dibits to overwrite
*/
public void update(Dibit[] dibits)
{
mPointer = mPointer - dibits.length;
if(mPointer < 0)
{
mPointer += mDelayLine.length;
}
for(Dibit dibit: dibits)
{
mDelayLine[mPointer++] = dibit;
mPointer %= mDelayLine.length;
}
}
/**
* Adjusts the pointer to correct a dibit stuff/delete.
* @param offset to adjust.
*/
public void adjustPointer(int offset)
{
mPointer += offset;
if(mPointer < 0)
{
mPointer += mDelayLine.length;
}
else if(mPointer >= mDelayLine.length)
{
mPointer -= mDelayLine.length;
}
}
/**
* Returns the most recently stored Dibit.
*/
public Dibit getLast()
{
int pointer = mPointer - 1;
if(pointer < 0)
{
pointer += mDelayLine.length;
}
return mDelayLine[pointer];
}
public void log()
{
StringBuilder sb = new StringBuilder();
int pointer = mPointer;
for(int i = 0; i < mDelayLine.length; i++)
{
Dibit dibit = mDelayLine[pointer];
sb.append(dibit.getBit1() ? "1" : "0");
sb.append(dibit.getBit2() ? "1" : "0");
sb.append(" ");
pointer++;
pointer = pointer % mDelayLine.length;
}
System.out.println(sb);
}
}