330 WIP on redesigning the P25 C4FM decoder. Creates a new decoder

based on the P25 LSM decoder using a costas loop and a gardner detector.
Updates the Demodulator Viewer FX application to add in a symbol chart
and a phase error chart.  The decoder won't lock on yet ... still a wip.
This commit is contained in:
Denny
2018-02-17 13:41:36 -05:00
parent 80c5ad1bc8
commit eaf7c7d11e
47 changed files with 3926 additions and 2093 deletions

View File

@@ -17,42 +17,61 @@
******************************************************************************/ ******************************************************************************/
package io.github.dsheirer.buffer; package io.github.dsheirer.buffer;
import org.apache.commons.math3.stat.descriptive.moment.Mean;
import org.apache.commons.math3.stat.descriptive.moment.Variance;
import org.apache.commons.math3.stat.descriptive.rank.Max;
import org.apache.commons.math3.stat.descriptive.rank.Min;
import java.util.Arrays; import java.util.Arrays;
/** /**
* Circular sample buffer - allocates a buffer and stores samples in a circular * Circular sample buffer - allocates a buffer and stores samples in a circular fashion, overwriting older samples with
* fashion, overwriting older samples with newly arrived samples. Initially * newly arrived samples. Initially fills buffer with 0-valued (default) samples or with a specified value.
* fills buffer with 0-valued samples
*
* Can be used as a delay-type buffer, to delay samples by the 'size' amount
*/ */
public class DoubleCircularBuffer public class DoubleCircularBuffer
{ {
double[] mBuffer; private Variance mVariance;
int mBufferPointer = 0; private Max mMax;
private Mean mMean;
private Min mMin;
private double[] mBuffer;
private int mBufferPointer = 0;
public DoubleCircularBuffer( int size ) /**
* Creates a circular double buffer of the specified size and all entries filled with the specified initial value.
* @param size of the buffer
* @param initialFillValue to fill the buffer entries
*/
public DoubleCircularBuffer(int size, double initialFillValue)
{ {
mBuffer = new double[ size ]; mBuffer = new double[size];
Arrays.fill(mBuffer, initialFillValue);
Arrays.fill( mBuffer, 0.0 );
} }
/** /**
* Puts the new value into the buffer and returns the oldest buffer value * Creates a circular double buffer of the specified size and all entries filled with an initial value of zero.
* that it replaced * @param size of the buffer
* @param newValue
* @return
*/ */
public double get( double newValue ) public DoubleCircularBuffer(int size)
{ {
double oldestSample = mBuffer[ mBufferPointer ]; this(size, 0.0);
}
mBuffer[ mBufferPointer ] = newValue; /**
* Puts the new value into the buffer and returns the oldest buffer value that it replaced
*
* @param newValue to add to the buffer
* @return oldest value that was overwritten by the new value
*/
public double get(double newValue)
{
double oldestSample = mBuffer[mBufferPointer];
mBuffer[mBufferPointer] = newValue;
mBufferPointer++; mBufferPointer++;
if( mBufferPointer >= mBuffer.length ) if(mBufferPointer >= mBuffer.length)
{ {
mBufferPointer = 0; mBufferPointer = 0;
} }
@@ -60,21 +79,90 @@ public class DoubleCircularBuffer
return oldestSample; return oldestSample;
} }
public double[] getAll()
{
int valuePointer = 0;
double[] values = new double[mBuffer.length];
int bufferPointer = mBufferPointer;
while(valuePointer < values.length)
{
values[valuePointer++] = mBuffer[bufferPointer++];
if(bufferPointer >= mBuffer.length)
{
bufferPointer = 0;
}
}
return values;
}
/**
* Places the new value into the buffer, overwriting the oldest value
* @param newValue to add to the buffer
*/
public void put(double newValue)
{
mBuffer[mBufferPointer] = newValue;
mBufferPointer++;
if(mBufferPointer >= mBuffer.length)
{
mBufferPointer = 0;
}
}
/** /**
* Returns the maximum from the values currently in the buffer * Returns the maximum from the values currently in the buffer
*/ */
public double max() public double max()
{ {
double max = 0.0d; if(mMax == null)
for( int x = 0; x < mBuffer.length; x++ )
{ {
if( mBuffer[ x ] > max ) mMax = new Max();
{
max = mBuffer[ x ];
}
} }
return max; return mMax.evaluate(mBuffer, 0, mBuffer.length);
}
/**
* Returns the minimum from the values currently in the buffer
*/
public double min()
{
if(mMin == null)
{
mMin = new Min();
}
return mMin.evaluate(mBuffer, 0, mBuffer.length);
}
/**
* Calculates the variance of the values contained in this buffer
*/
public double variance()
{
if(mVariance == null)
{
mVariance = new Variance();
}
return mVariance.evaluate(mBuffer);
}
/**
* Calculates the average/mean of the values contained in this buffer
*/
public double mean()
{
if(mMean == null)
{
mMean = new Mean();
}
return mMean.evaluate(mBuffer, 0, mBuffer.length);
} }
} }

View File

@@ -39,15 +39,24 @@ public class FilterViewer extends Application
*/ */
private float[] getFilter() private float[] getFilter()
{ {
// FIRFilterSpecification specification = FIRFilterSpecification.lowPassBuilder()
// .sampleRate(48000)
// .gridDensity(16)
// .passBandCutoff(2500)
// .passBandAmplitude(1.0)
// .passBandRipple(0.01)
// .stopBandStart(4000)
// .stopBandAmplitude(0.0)
// .stopBandRipple(0.008)
// .build();
FIRFilterSpecification specification = FIRFilterSpecification.lowPassBuilder() FIRFilterSpecification specification = FIRFilterSpecification.lowPassBuilder()
.sampleRate(48000) .sampleRate((int)48000.0)
.gridDensity(16) .passBandCutoff(6000)
.passBandCutoff(2500)
.passBandAmplitude(1.0) .passBandAmplitude(1.0)
.passBandRipple(0.01) .passBandRipple(0.1)
.stopBandStart(4000)
.stopBandAmplitude(0.0) .stopBandAmplitude(0.0)
.stopBandRipple(0.008) .stopBandStart(6250)
.stopBandRipple(0.01)
.build(); .build();
// FIRFilterSpecification specification = FIRFilterSpecification.highPassBuilder() // FIRFilterSpecification specification = FIRFilterSpecification.highPassBuilder()

View File

@@ -1,8 +1,24 @@
/*******************************************************************************
* 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.filter.fir.complex; package io.github.dsheirer.dsp.filter.fir.complex;
import io.github.dsheirer.dsp.filter.fir.FIRFilter; import io.github.dsheirer.dsp.filter.fir.FIRFilter;
import io.github.dsheirer.dsp.filter.fir.real.RealFIRFilter; import io.github.dsheirer.dsp.filter.fir.real.RealFIRFilter;
import io.github.dsheirer.sample.complex.Complex; import io.github.dsheirer.sample.complex.Complex;
import io.github.dsheirer.sample.complex.ComplexBuffer;
public class ComplexFIRFilter extends FIRFilter public class ComplexFIRFilter extends FIRFilter
{ {
@@ -16,10 +32,10 @@ public class ComplexFIRFilter extends FIRFilter
* @param coefficients - filter taps * @param coefficients - filter taps
* @param gain - gain to apply to filtered outputs - use 1.0f for no gain * @param gain - gain to apply to filtered outputs - use 1.0f for no gain
*/ */
public ComplexFIRFilter( float[] coefficients, float gain ) public ComplexFIRFilter(float[] coefficients, float gain)
{ {
mIFilter = new RealFIRFilter( coefficients, gain ); mIFilter = new RealFIRFilter(coefficients, gain);
mQFilter = new RealFIRFilter( coefficients, gain ); mQFilter = new RealFIRFilter(coefficients, gain);
} }
public float[] getCoefficients() public float[] getCoefficients()
@@ -27,22 +43,42 @@ public class ComplexFIRFilter extends FIRFilter
return mIFilter.getCoefficients(); return mIFilter.getCoefficients();
} }
public float filterInphase( float sample ) public float filterInphase(float sample)
{ {
return mIFilter.filter( sample ); return mIFilter.filter(sample);
} }
public float filterQuadrature( float sample ) public float filterQuadrature(float sample)
{ {
return mQFilter.filter( sample ); return mQFilter.filter(sample);
} }
public Complex filter( Complex sample ) public Complex filter(Complex sample)
{ {
float i = filterInphase( sample.inphase() ); float i = filterInphase(sample.inphase());
float q = filterQuadrature( sample.quadrature() ); float q = filterQuadrature(sample.quadrature());
return new Complex( i, q ); return new Complex(i, q);
}
/**
* Filters the complex samples from the buffer and returns a new complex buffer with the filtered output
*
* @param buffer with complex samples to filter
* @return new buffer containing filtered complex samples
*/
public ComplexBuffer filter(ComplexBuffer buffer)
{
float[] samples = buffer.getSamples();
float[] filtered = new float[samples.length];
for(int x = 0; x < samples.length; x += 2)
{
filtered[x] = filterInphase(samples[x]);
filtered[x + 1] = filterQuadrature(samples[x + 1]);
}
return new ComplexBuffer(filtered);
} }
@Override @Override

View File

@@ -3,8 +3,7 @@ package io.github.dsheirer.dsp.filter.fir.complex;
import io.github.dsheirer.sample.Listener; import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.complex.ComplexBuffer; import io.github.dsheirer.sample.complex.ComplexBuffer;
public class ComplexFIRFilter_CB_CB extends ComplexFIRFilter public class ComplexFIRFilter_CB_CB extends ComplexFIRFilter implements Listener<ComplexBuffer>
implements Listener<ComplexBuffer>
{ {
private Listener<ComplexBuffer> mListener; private Listener<ComplexBuffer> mListener;

View File

@@ -1,32 +1,25 @@
/*******************************************************************************
* 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.gain; package io.github.dsheirer.dsp.gain;
import io.github.dsheirer.buffer.FloatCircularBuffer; import io.github.dsheirer.buffer.FloatCircularBuffer;
import io.github.dsheirer.sample.complex.Complex; import io.github.dsheirer.sample.complex.Complex;
import io.github.dsheirer.sample.complex.ComplexBuffer;
import io.github.dsheirer.sample.complex.ComplexSampleListener; import io.github.dsheirer.sample.complex.ComplexSampleListener;
/*******************************************************************************
* SDR Trunk
* Copyright (C) 2015 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/>
*
* This class is modeled using concepts detailed in the GNURadio
* implementation of feed forward AGC class located at:
* https://github.com/gnuradio/gnuradio/blob/master/gr-analog/lib/
* feedforward_agc_cc_impl.cc
*
******************************************************************************/
public class ComplexFeedForwardGainControl implements ComplexSampleListener public class ComplexFeedForwardGainControl implements ComplexSampleListener
{ {
public static final float OBJECTIVE_ENVELOPE = 1.0f; public static final float OBJECTIVE_ENVELOPE = 1.0f;
@@ -49,11 +42,10 @@ public class ComplexFeedForwardGainControl implements ComplexSampleListener
* gain value to limit how quickly the gain value will increase or decrease. * gain value to limit how quickly the gain value will increase or decrease.
* *
* @param window - history size to use in detecting maximum envelope value * @param window - history size to use in detecting maximum envelope value
* @param damping - a value between 0 < damping <= 1.0;
*/ */
public ComplexFeedForwardGainControl( int window ) public ComplexFeedForwardGainControl(int window)
{ {
mEnvelopeHistory = new FloatCircularBuffer( window ); mEnvelopeHistory = new FloatCircularBuffer(window);
} }
public void dispose() public void dispose()
@@ -62,11 +54,22 @@ public class ComplexFeedForwardGainControl implements ComplexSampleListener
} }
@Override @Override
public void receive( float inphase, float quadrature ) public void receive(float inphase, float quadrature)
{ {
float envelope = Complex.envelope( inphase, quadrature ); process(inphase, quadrature);
if( envelope > mMaxEnvelope ) /* Apply current gain value to the sample and send to the listener */
if(mListener != null)
{
mListener.receive(inphase *= mGain, quadrature *= mGain);
}
}
private void process(float inphase, float quadrature)
{
float envelope = Complex.envelope(inphase, quadrature);
if(envelope > mMaxEnvelope)
{ {
mMaxEnvelope = envelope; mMaxEnvelope = envelope;
@@ -74,17 +77,17 @@ public class ComplexFeedForwardGainControl implements ComplexSampleListener
} }
/* Replace oldest envelope value with current envelope value */ /* Replace oldest envelope value with current envelope value */
float oldestEnvelope = mEnvelopeHistory.get( envelope ); float oldestEnvelope = mEnvelopeHistory.get(envelope);
/* If the oldest envelope value was the max envelope value, then we /* If the oldest envelope value was the max envelope value, then we
* have to rediscover the max value from the envelope history */ * have to rediscover the max value from the envelope history */
if( mMaxEnvelope == oldestEnvelope && mMaxEnvelope != envelope ) if(mMaxEnvelope == oldestEnvelope && mMaxEnvelope != envelope)
{ {
mMaxEnvelope = MINIMUM_ENVELOPE; mMaxEnvelope = MINIMUM_ENVELOPE;
for( float value: mEnvelopeHistory.getBuffer() ) for(float value : mEnvelopeHistory.getBuffer())
{ {
if( value > mMaxEnvelope ) if(value > mMaxEnvelope)
{ {
mMaxEnvelope = value; mMaxEnvelope = value;
} }
@@ -92,12 +95,6 @@ public class ComplexFeedForwardGainControl implements ComplexSampleListener
adjustGain(); adjustGain();
} }
/* Apply current gain value to the sample and send to the listener */
if( mListener != null )
{
mListener.receive( inphase *= mGain, quadrature *= mGain );
}
} }
private void adjustGain() private void adjustGain()
@@ -105,8 +102,24 @@ public class ComplexFeedForwardGainControl implements ComplexSampleListener
mGain = OBJECTIVE_ENVELOPE / mMaxEnvelope; mGain = OBJECTIVE_ENVELOPE / mMaxEnvelope;
} }
public void setListener( ComplexSampleListener listener ) public void setListener(ComplexSampleListener listener)
{ {
mListener = listener; mListener = listener;
} }
public ComplexBuffer filter(ComplexBuffer complexBuffer)
{
float[] samples = complexBuffer.getSamples();
float[] processed = new float[samples.length];
for(int x = 0; x < samples.length; x += 2)
{
process(samples[x], samples[x + 1]);
processed[x] = samples[x] * mGain;
processed[x + 1] = samples[x + 1] * mGain;
}
return new ComplexBuffer(processed);
}
} }

View File

@@ -51,8 +51,7 @@ public class Oscillator
*/ */
private void update() private void update()
{ {
float anglePerSample = float anglePerSample = (float)( 2.0d * Math.PI * mFrequency / mSampleRate );
(float)( 2.0d * Math.PI * mFrequency / mSampleRate );
mAnglePerSample = Complex.fromAngle( anglePerSample ); mAnglePerSample = Complex.fromAngle( anglePerSample );
} }

View File

@@ -0,0 +1,30 @@
/*******************************************************************************
* 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 class DQPSKSymbolPhaseErrorCalculator extends QPSKSymbolPhaseErrorCalculator
{
//Negative 45 degrees rotation to offset for differential additive 45 degrees of rotation
public static final Complex DIFFERENTIAL_OFFSET = Complex.fromAngle(Math.PI / -4.0d);
@Override
public void adjust(Complex symbol)
{
symbol.multiply(DIFFERENTIAL_OFFSET);
}
}

View File

@@ -0,0 +1,82 @@
/*******************************************************************************
* 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 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 = (previous.inphase() - current.inphase()) * middle.inphase();
mErrorQuadrature = (previous.quadrature() - current.quadrature()) * 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;
}
}

View File

@@ -0,0 +1,29 @@
/*******************************************************************************
* 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);
}

View File

@@ -0,0 +1,35 @@
/*******************************************************************************
* 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
{
/**
* Adjusts the calculated symbol as necessary before calculating any phase error. This might be useful for
* differential encoding to remove a 45 degree rotational spin.
* @param symbol to adjust
*/
void adjust(Complex symbol);
/**
* 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);
}

View File

@@ -0,0 +1,187 @@
/*******************************************************************************
* 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.filter.interpolator.RealInterpolator;
import io.github.dsheirer.sample.complex.Complex;
public class InterpolatingSymbolBuffer
{
private Complex mMiddleSample = new Complex(0,0);
private Complex mCurrentSample = new Complex(0,0);
private float[] mDelayLineInphase;
private float[] mDelayLineQuadrature;
private float mMu; //Sample Counter
private float mGainMu = 0.05f; //Sample Counter Gain
private float mOmega;
private float mGainOmega = 0.1f * mGainMu * mGainMu;
private float mOmegaRel = 0.005f;
private float mOmegaMid;
private int mDelayLinePointer = 0;
private int mTwiceSamplesPerSymbol;
private RealInterpolator mInterpolator = new RealInterpolator(1.0f);
public InterpolatingSymbolBuffer(float samplesPerSymbol)
{
mMu = samplesPerSymbol;
mTwiceSamplesPerSymbol = (int)Math.floor(2.0 * samplesPerSymbol);
mDelayLineInphase = new float[2 * mTwiceSamplesPerSymbol];
mDelayLineQuadrature = new float[2 * mTwiceSamplesPerSymbol];
mOmega = samplesPerSymbol;
mOmegaMid = samplesPerSymbol;
}
public void receive(Complex currentSample)
{
mMu--;
//Fill up the delay line to use with the interpolator
mDelayLineInphase[mDelayLinePointer] = currentSample.inphase();
mDelayLineInphase[mDelayLinePointer + mTwiceSamplesPerSymbol] = currentSample.inphase();
mDelayLineQuadrature[mDelayLinePointer] = currentSample.quadrature();
mDelayLineQuadrature[mDelayLinePointer + mTwiceSamplesPerSymbol] = currentSample.quadrature();
//Increment pointer and keep pointer in bounds
mDelayLinePointer = (mDelayLinePointer + 1) % mTwiceSamplesPerSymbol;
}
/**
* Updates the internal sample counter with additional samples to add to the symbol sample counter.
* @param samplesToAdd to the sample counter
*/
public void increaseSampleCounter(float samplesToAdd)
{
mMu += samplesToAdd;
}
/**
* Adjusts samples per symbol and symbol timing counters and increments the sample counter to collect another
* symbol.
*
* @param symbolTimingError from a symbol timing error detector
*/
public void resetAndAdjust(float symbolTimingError)
{
//mOmega is samples per symbol and is constrained to floating between +/- .005 of the nominal samples per
//symbol
mOmega = mOmega + mGainOmega * symbolTimingError;
mOmega = mOmegaMid + clip(mOmega - mOmegaMid, mOmegaRel);
//Add another symbol's worth of samples to the counter and adjust timing based on gardner error
increaseSampleCounter((mOmega + (mGainMu * symbolTimingError)));
}
/**
* Indicates if this buffer has accumulated a enough samples to represent a full symbol
*/
public boolean hasSymbol()
{
return mMu < 1.0f;
}
/**
* Interpolated middle sample for the symbol. Note: this method should only be invoked after testing for a
* complete symbol with the hasSymbol() method.
*/
public Complex getMiddleSample()
{
/* Calculate interpolated middle sample and current sample */
mMiddleSample.setValues(getInphase(mMu), getQuadrature(mMu));
return mMiddleSample;
}
/**
* Interpolated current sample for the symbol. This sample represents the ideal symbol sampling point.
* Note: this method should only be invoked after testing for a complete symbol with the hasSymbol() method.
*/
public Complex getCurrentSample()
{
float half_omega = mOmega / 2.0f;
int half_sps = (int)Math.floor(half_omega);
float half_mu = mMu + half_omega - half_sps;
if(half_mu > 1.0)
{
half_mu -= 1.0;
half_sps += 1;
}
mCurrentSample.setValues(getInphase(half_mu, half_sps), getQuadrature(half_mu, half_sps));
return mCurrentSample;
}
/**
* Returns the interpolated inphase value for the specified offset
* @param interpolation into the buffer to calculate the interpolated sample
* @return inphase value of the interpolated sample
*/
public float getInphase(float interpolation)
{
return mInterpolator.filter(mDelayLineInphase, mDelayLinePointer, interpolation);
}
/**
* Returns the interpolated inphase value for the specified offset
* @param interpolation into the buffer to calculate the interpolated sample
* @return inphase value of the interpolated sample
*/
public float getInphase(float interpolation, int indexOffet)
{
return mInterpolator.filter(mDelayLineInphase, mDelayLinePointer + indexOffet, interpolation);
}
/**
* Returns the interpolated quadrature value for the specified offset
* @param interpolation into the buffer to calculate the interpolated sample
* @return quadrature value of the interpolated sample
*/
public float getQuadrature(float interpolation)
{
return mInterpolator.filter(mDelayLineQuadrature, mDelayLinePointer, interpolation);
}
/**
* Returns the interpolated quadrature value for the specified offset
* @param interpolation into the buffer to calculate the interpolated sample
* @return quadrature value of the interpolated sample
*/
public float getQuadrature(float interpolation, int indexOffset)
{
return mInterpolator.filter(mDelayLineQuadrature, mDelayLinePointer + indexOffset, interpolation);
}
/**
* 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;
}
}

View File

@@ -0,0 +1,28 @@
/*******************************************************************************
* 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;
}
}

View File

@@ -2,7 +2,7 @@ package io.github.dsheirer.dsp.psk;
/******************************************************************************* /*******************************************************************************
* SDR Trunk * SDR Trunk
* Copyright (C) 2014, 2015 Dennis Sheirer * Copyright (C) 2014 - 2018 Dennis Sheirer
* *
* Gardner detector, Costas loop and Interpolator derived from: * Gardner detector, Costas loop and Interpolator derived from:
* *
@@ -32,6 +32,7 @@ package io.github.dsheirer.dsp.psk;
import io.github.dsheirer.buffer.FloatAveragingBuffer; import io.github.dsheirer.buffer.FloatAveragingBuffer;
import io.github.dsheirer.dsp.filter.interpolator.RealInterpolator; import io.github.dsheirer.dsp.filter.interpolator.RealInterpolator;
import io.github.dsheirer.dsp.psk.pll.IPhaseLockedLoop;
import io.github.dsheirer.dsp.symbol.Dibit; import io.github.dsheirer.dsp.symbol.Dibit;
import io.github.dsheirer.instrument.Instrumentable; import io.github.dsheirer.instrument.Instrumentable;
import io.github.dsheirer.instrument.tap.Tap; import io.github.dsheirer.instrument.tap.Tap;
@@ -60,17 +61,17 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
private List<TapGroup> mAvailableTaps; private List<TapGroup> mAvailableTaps;
/* 45 degree rotation angle */ /* 45 degree rotation angle */
public static final float THETA = (float)( Math.PI / 4.0d ); public static final float THETA = (float)(Math.PI / 4.0d);
/* 45 degree point */ /* 45 degree point */
public static final Complex POINT_45_DEGREES = public static final Complex POINT_45_DEGREES = new Complex((float)Math.sin(THETA), (float)Math.cos(THETA));
new Complex( (float)Math.sin( THETA ), (float)Math.cos( THETA ) );
private Listener<Complex> mSymbolListener; private Listener<Complex> mSymbolListener;
private GardnerSymbolTiming mGardnerDetector = new GardnerSymbolTiming(); private GardnerSymbolTiming mGardnerDetector = new GardnerSymbolTiming();
private CostasLoop mCostasLoop = new CostasLoop(); private CostasLoop mCostasLoop = new CostasLoop();
private QPSKSymbolDecoder mQPSKSymbolDecoder = new QPSKSymbolDecoder();
private IFrequencyChangeListener mFrequencyChangeListener; private IFrequencyChangeListener mFrequencyChangeListener;
@@ -80,13 +81,18 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
{ {
} }
public CostasLoop getCostasLoop()
{
return mCostasLoop;
}
public void dispose() public void dispose()
{ {
mSymbolListener = null; mSymbolListener = null;
mFrequencyChangeListener = null; mFrequencyChangeListener = null;
} }
public void setSymbolListener( Listener<Complex> listener ) public void setSymbolListener(Listener<Complex> listener)
{ {
mSymbolListener = listener; mSymbolListener = listener;
} }
@@ -97,9 +103,9 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
} }
@Override @Override
public void receive( float inphase, float quadrature ) public void receive(float inphase, float quadrature)
{ {
mGardnerDetector.receive( inphase, quadrature ); mGardnerDetector.receive(inphase, quadrature);
} }
/** /**
@@ -108,21 +114,21 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
* *
* @param correction - value in radians * @param correction - value in radians
*/ */
public void correctPhaseError( double correction ) public void correctPhaseError(double correction)
{ {
mCostasLoop.correctPhaseError( correction ); mCostasLoop.correctPhaseError(correction);
} }
/** /**
* Constrains value to the range of ( -maximum <> maximum ) * Constrains value to the range of ( -maximum <> maximum )
*/ */
public static float clip( float value, float maximum ) public static float clip(float value, float maximum)
{ {
if( value > maximum ) if(value > maximum)
{ {
return maximum; return maximum;
} }
else if( value < -maximum ) else if(value < -maximum)
{ {
return -maximum; return -maximum;
} }
@@ -134,24 +140,24 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
* Constrains timing error to +/- the maximum value and corrects any * Constrains timing error to +/- the maximum value and corrects any
* floating point invalid numbers * floating point invalid numbers
*/ */
private float normalize( float error, float maximum ) private float normalize(float error, float maximum)
{ {
if( Float.isNaN( error ) ) if(Float.isNaN(error))
{ {
return 0.0f; return 0.0f;
} }
else else
{ {
return clip( error, maximum ); return clip(error, maximum);
} }
} }
public void addListener( IFrequencyChangeListener listener ) public void addListener(IFrequencyChangeListener listener)
{ {
mFrequencyChangeListener = listener; mFrequencyChangeListener = listener;
} }
public void removeListener( IFrequencyChangeListener listener ) public void removeListener(IFrequencyChangeListener listener)
{ {
mFrequencyChangeListener = null; mFrequencyChangeListener = null;
} }
@@ -166,15 +172,15 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
/* Set the trigger threshold at half of the maximum costas loop control /* Set the trigger threshold at half of the maximum costas loop control
* frequency */ * frequency */
private static final float CORRECTION_THRESHOLD_FREQUENCY = private static final float CORRECTION_THRESHOLD_FREQUENCY =
( 2.0f * (float)Math.PI * 600.0f ) / 48000.0f; (2.0f * (float)Math.PI * 600.0f) / 48000.0f;
private FloatAveragingBuffer mBuffer = new FloatAveragingBuffer( 40 ); private FloatAveragingBuffer mBuffer = new FloatAveragingBuffer(40);
private long mFrequencyError = 0; private long mFrequencyError = 0;
private int mCounter = 0; private int mCounter = 0;
public void receive( float frequency ) public void receive(float frequency)
{ {
// mCounter++; // mCounter++;
// //
@@ -224,8 +230,8 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
public static final int SAMPLES_PER_SYMBOL = 10; public static final int SAMPLES_PER_SYMBOL = 10;
public static final int TWICE_SAMPLES_PER_SYMBOL = 20; public static final int TWICE_SAMPLES_PER_SYMBOL = 20;
private float[] mDelayLineInphase = new float[ 2 * TWICE_SAMPLES_PER_SYMBOL ]; private float[] mDelayLineInphase = new float[2 * TWICE_SAMPLES_PER_SYMBOL];
private float[] mDelayLineQuadrature = new float[ 2 * TWICE_SAMPLES_PER_SYMBOL ]; private float[] mDelayLineQuadrature = new float[2 * TWICE_SAMPLES_PER_SYMBOL];
private int mDelayLinePointer = 0; private int mDelayLinePointer = 0;
@@ -239,11 +245,11 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
private float mOmegaRel = 0.005f; private float mOmegaRel = 0.005f;
private float mOmegaMid = 10.0f; private float mOmegaMid = 10.0f;
private RealInterpolator mInterpolator = new RealInterpolator( 1.0f ); private RealInterpolator mInterpolator = new RealInterpolator(1.0f);
private Complex mPreviousSample = new Complex( 0, 0 ); private Complex mPreviousSample = new Complex(0, 0);
private Complex mPreviousMiddleSample = new Complex( 0, 0 ); private Complex mPreviousMiddleSample = new Complex(0, 0);
private Complex mPreviousSymbol = new Complex( 0, 0 ); private Complex mPreviousSymbol = new Complex(0, 0);
/** /**
* Provides symbol sampling timing control * Provides symbol sampling timing control
@@ -253,7 +259,7 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
} }
@Override @Override
public void receive( float inphase, float quadrature ) public void receive(float inphase, float quadrature)
{ {
/* Count down samples per symbol until we calculate the symbol */ /* Count down samples per symbol until we calculate the symbol */
mMu--; mMu--;
@@ -265,27 +271,27 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
Complex costas = mCostasLoop.getCurrentVector(); Complex costas = mCostasLoop.getCurrentVector();
float derotatedInphase = Complex.multiplyInphase( inphase, quadrature, costas.inphase(), costas.quadrature() ); float derotatedInphase = Complex.multiplyInphase(inphase, quadrature, costas.inphase(), costas.quadrature());
float derotatedQuadrature = Complex.multiplyQuadrature( inphase, quadrature, costas.inphase(), costas.quadrature() ); float derotatedQuadrature = Complex.multiplyQuadrature(inphase, quadrature, costas.inphase(), costas.quadrature());
/* Fill up the delay line to use with the interpolator */ /* Fill up the delay line to use with the interpolator */
mDelayLineInphase[ mDelayLinePointer ] = derotatedInphase; mDelayLineInphase[mDelayLinePointer] = derotatedInphase;
mDelayLineInphase[ mDelayLinePointer + TWICE_SAMPLES_PER_SYMBOL ] = derotatedInphase; mDelayLineInphase[mDelayLinePointer + TWICE_SAMPLES_PER_SYMBOL] = derotatedInphase;
mDelayLineQuadrature[ mDelayLinePointer ] = derotatedQuadrature; mDelayLineQuadrature[mDelayLinePointer] = derotatedQuadrature;
mDelayLineQuadrature[ mDelayLinePointer + TWICE_SAMPLES_PER_SYMBOL ] = derotatedQuadrature; mDelayLineQuadrature[mDelayLinePointer + TWICE_SAMPLES_PER_SYMBOL] = derotatedQuadrature;
/* Increment pointer and keep pointer in bounds */ /* Increment pointer and keep pointer in bounds */
mDelayLinePointer = ( mDelayLinePointer + 1 ) % TWICE_SAMPLES_PER_SYMBOL; mDelayLinePointer = (mDelayLinePointer + 1) % TWICE_SAMPLES_PER_SYMBOL;
/* Calculate the symbol once we've stored enough samples */ /* Calculate the symbol once we've stored enough samples */
if( mMu <= 1.0f ) if(mMu <= 1.0f)
{ {
float half_omega = mOmega / 2.0f; float half_omega = mOmega / 2.0f;
int half_sps = (int)Math.floor( half_omega ); int half_sps = (int)Math.floor(half_omega);
float half_mu = mMu + half_omega - (float)half_sps; float half_mu = mMu + half_omega - (float)half_sps;
if( half_mu > 1.0 ) if(half_mu > 1.0)
{ {
half_mu -= 1.0; half_mu -= 1.0;
half_sps += 1; half_sps += 1;
@@ -293,70 +299,70 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
/* Calculate interpolated middle sample and current sample */ /* Calculate interpolated middle sample and current sample */
float middleSampleInphase = mInterpolator.filter( float middleSampleInphase = mInterpolator.filter(
mDelayLineInphase, mDelayLinePointer, mMu ); mDelayLineInphase, mDelayLinePointer, mMu);
float middleSampleQuadrature = mInterpolator.filter( float middleSampleQuadrature = mInterpolator.filter(
mDelayLineQuadrature, mDelayLinePointer, mMu ); mDelayLineQuadrature, mDelayLinePointer, mMu);
int index = mDelayLinePointer + half_sps; int index = mDelayLinePointer + half_sps;
float currentSampleInphase = mInterpolator.filter( float currentSampleInphase = mInterpolator.filter(
mDelayLineInphase, index, half_mu ); mDelayLineInphase, index, half_mu);
float currentSampleQuadrature = mInterpolator.filter( float currentSampleQuadrature = mInterpolator.filter(
mDelayLineQuadrature, index, half_mu ); mDelayLineQuadrature, index, half_mu);
/* Multiply current sample and conjugate (negated quadrature) of /* Multiply current sample and conjugate (negated quadrature) of
* previous sample to get symbols to use for gardner error feedback */ * previous sample to get symbols to use for gardner error feedback */
Complex middleSymbol = Complex.multiply( middleSampleInphase, Complex middleSymbol = Complex.multiply(middleSampleInphase,
middleSampleQuadrature, mPreviousMiddleSample.conjugate() ); middleSampleQuadrature, mPreviousMiddleSample.conjugate());
Complex currentSymbol = Complex.multiply( currentSampleInphase, Complex currentSymbol = Complex.multiply(currentSampleInphase,
currentSampleQuadrature, mPreviousSample.conjugate() ); currentSampleQuadrature, mPreviousSample.conjugate());
/* Set gain to unity */ /* Set gain to unity */
middleSymbol.normalize(); middleSymbol.normalize();
currentSymbol.normalize(); currentSymbol.normalize();
/* Gardner timing error calculations */ /* Gardner timing error calculations */
float errorInphase = ( mPreviousSymbol.inphase() - float errorInphase = (mPreviousSymbol.inphase() -
currentSymbol.inphase() ) * middleSymbol.inphase(); currentSymbol.inphase()) * middleSymbol.inphase();
float errorQuadrature = ( mPreviousSymbol.quadrature() - float errorQuadrature = (mPreviousSymbol.quadrature() -
currentSymbol.quadrature() ) * middleSymbol.quadrature(); currentSymbol.quadrature()) * middleSymbol.quadrature();
float gardnerError = normalize( errorInphase + errorQuadrature, 1.0f ); float gardnerError = normalize(errorInphase + errorQuadrature, 1.0f);
if( mEyeDiagramDataTap != null ) if(mEyeDiagramDataTap != null)
{ {
mEyeDiagramDataTap.receive( mEyeDiagramDataTap.receive(
new EyeDiagramData( new EyeDiagramData(
Arrays.copyOfRange( mDelayLineInphase, 0, 20 ), Arrays.copyOfRange(mDelayLineInphase, 0, 20),
Arrays.copyOfRange( mDelayLineQuadrature, 0, 20 ), Arrays.copyOfRange(mDelayLineQuadrature, 0, 20),
mMu, (float)half_sps + half_mu, gardnerError ) ); mMu, (float)half_sps + half_mu, gardnerError));
} }
/* mOmega is samples per symbol and is constrained to floating /* mOmega is samples per symbol and is constrained to floating
* between +/- .005 of the nominal 10.0 samples per symbol */ * between +/- .005 of the nominal 10.0 samples per symbol */
mOmega = mOmega + mGainOmega * gardnerError; mOmega = mOmega + mGainOmega * gardnerError;
mOmega = mOmegaMid + clip( mOmega - mOmegaMid, mOmegaRel ); mOmega = mOmegaMid + clip(mOmega - mOmegaMid, mOmegaRel);
/* Adjust sample timing based on error of current sample */ /* Adjust sample timing based on error of current sample */
mMu += mOmega + ( mGainMu * gardnerError ); mMu += mOmega + (mGainMu * gardnerError);
/* Store current samples/symbols to use for the next period */ /* Store current samples/symbols to use for the next period */
mPreviousSample.setValues( currentSampleInphase, currentSampleQuadrature ); mPreviousSample.setValues(currentSampleInphase, currentSampleQuadrature);
mPreviousMiddleSample.setValues( middleSampleInphase, middleSampleQuadrature ); mPreviousMiddleSample.setValues(middleSampleInphase, middleSampleQuadrature);
mPreviousSymbol = currentSymbol; mPreviousSymbol = currentSymbol;
/* Update costas loop using phase error present in current /* Update costas loop using phase error present in current
* symbol. The symbol is rotated from star orientation to polar * symbol. The symbol is rotated from star orientation to polar
* orientation to simplify error calculation */ * orientation to simplify error calculation */
mCostasLoop.receive( currentSymbol ); mCostasLoop.receive(currentSymbol);
// mCostasLoop.receive( // mCostasLoop.receive(
// ComplexSample.multiply( currentSymbol, POINT_45_DEGREES ) ); // ComplexSample.multiply( currentSymbol, POINT_45_DEGREES ) );
/* Dispatch the differentiated symbol to the registered listener */ /* Dispatch the differentiated symbol to the registered listener */
if( mSymbolListener != null ) if(mSymbolListener != null)
{ {
mSymbolListener.receive( currentSymbol ); mSymbolListener.receive(currentSymbol);
} }
} }
} }
@@ -373,27 +379,27 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
* gnuradio/mpsk_receiver_cc using initialization values from KA1RBI's * gnuradio/mpsk_receiver_cc using initialization values from KA1RBI's
* OP25/cqpsk.py * OP25/cqpsk.py
*/ */
public class CostasLoop implements Listener<Complex> public class CostasLoop implements Listener<Complex>, IPhaseLockedLoop
{ {
public static final double TWO_PI = 2.0 * Math.PI; public static final double TWO_PI = 2.0 * Math.PI;
private static final float MAXIMUM_FREQUENCY = private static final float MAXIMUM_FREQUENCY =
( 2400.0f * (float)TWO_PI ) / 48000.0f; (2400.0f * (float)TWO_PI) / 48000.0f;
/* http://www.trondeau.com/blog/2011/8/13/control-loop-gain-values.html */ /* http://www.trondeau.com/blog/2011/8/13/control-loop-gain-values.html */
private float mDamping = (float)Math.sqrt( 2.0 ) / 2.0f; private float mDamping = (float)Math.sqrt(2.0) / 2.0f;
/* Use denominator between 100 (most) and 400 (least) to adjust costas /* Use denominator between 100 (most) and 400 (least) to adjust costas
* loop control level */ * loop control level */
private float mLoopBandwidth = (float)( TWO_PI / 400.0d ); private float mLoopBandwidth = (float)(TWO_PI / 400.0d);
private float mAlphaGain = ( 4.0f * mDamping * mLoopBandwidth ) / private float mAlphaGain = (4.0f * mDamping * mLoopBandwidth) /
( 1.0f + ( 2.0f * mDamping * mLoopBandwidth ) + (1.0f + (2.0f * mDamping * mLoopBandwidth) +
( mLoopBandwidth * mLoopBandwidth ) ); (mLoopBandwidth * mLoopBandwidth));
private float mBetaGain = ( 4.0f * mLoopBandwidth * mLoopBandwidth ) / private float mBetaGain = (4.0f * mLoopBandwidth * mLoopBandwidth) /
( 1.0f + ( 2.0f * mDamping * mLoopBandwidth ) + (1.0f + (2.0f * mDamping * mLoopBandwidth) +
( mLoopBandwidth * mLoopBandwidth ) ); (mLoopBandwidth * mLoopBandwidth));
private float mLoopPhase = 0.0f; private float mLoopPhase = 0.0f;
@@ -417,16 +423,16 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
* *
* @param correction - correction value in radians * @param correction - correction value in radians
*/ */
public void correctPhaseError( double correction ) public void correctPhaseError(double correction)
{ {
mLoopFrequency += correction; mLoopFrequency += correction;
if( mLoopFrequency > MAXIMUM_FREQUENCY ) if(mLoopFrequency > MAXIMUM_FREQUENCY)
{ {
mLoopFrequency -= 2.0d * MAXIMUM_FREQUENCY; mLoopFrequency -= 2.0d * MAXIMUM_FREQUENCY;
} }
if( mLoopFrequency < -MAXIMUM_FREQUENCY ) if(mLoopFrequency < -MAXIMUM_FREQUENCY)
{ {
mLoopFrequency += 2.0d * MAXIMUM_FREQUENCY; mLoopFrequency += 2.0d * MAXIMUM_FREQUENCY;
} }
@@ -443,14 +449,26 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
unwrapPhase(); unwrapPhase();
} }
@Override
public void adjust(double error)
{
adjust(error);
}
@Override
public void correctInversion(double correction)
{
correctPhaseError(correction);
}
private void unwrapPhase() private void unwrapPhase()
{ {
while( mLoopPhase > TWO_PI ) while(mLoopPhase > TWO_PI)
{ {
mLoopPhase -= TWO_PI; mLoopPhase -= TWO_PI;
} }
while( mLoopPhase < -TWO_PI ) while(mLoopPhase < -TWO_PI)
{ {
mLoopPhase += TWO_PI; mLoopPhase += TWO_PI;
} }
@@ -462,20 +480,26 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
public Complex getCurrentVector() public Complex getCurrentVector()
{ {
// return ComplexSample.fromAngle( mLoopPhase + THETA ); // return ComplexSample.fromAngle( mLoopPhase + THETA );
return Complex.fromAngle( mLoopPhase ); return Complex.fromAngle(mLoopPhase);
} }
@Override @Override
public void receive( Complex complex ) public Complex incrementAndGetCurrentVector()
{
return null;
}
@Override
public void receive(Complex complex)
{ {
/* Calculate phase error */ /* Calculate phase error */
float phaseError = getPhaseError( complex ); float phaseError = getPhaseError(complex);
Dibit d = QPSKPolarSlicer.decide( complex ); Dibit d = mQPSKSymbolDecoder.decode(complex);
// mLog.debug( "Dibit: " + d.name() + " Error: " + phaseError ); // mLog.debug( "Dibit: " + d.name() + " Error: " + phaseError );
/* Adjust for phase error */ /* Adjust for phase error */
adjust( phaseError ); adjust(phaseError);
} }
/** /**
@@ -484,7 +508,7 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
* *
* @param phase_error - (-)= late and (+)= early * @param phase_error - (-)= late and (+)= early
*/ */
private void adjust( float phase_error ) private void adjust(float phase_error)
{ {
mLoopFrequency += mBetaGain * phase_error; mLoopFrequency += mBetaGain * phase_error;
mLoopPhase += mLoopFrequency + mAlphaGain * phase_error; mLoopPhase += mLoopFrequency + mAlphaGain * phase_error;
@@ -502,14 +526,14 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
private void limitFrequency() private void limitFrequency()
{ {
/* Check for and issue tuner offset correction */ /* Check for and issue tuner offset correction */
mFrequencyControl.receive( mLoopFrequency ); mFrequencyControl.receive(mLoopFrequency);
if( mLoopFrequency > MAXIMUM_FREQUENCY ) if(mLoopFrequency > MAXIMUM_FREQUENCY)
{ {
mLoopFrequency = MAXIMUM_FREQUENCY; mLoopFrequency = MAXIMUM_FREQUENCY;
} }
if( mLoopFrequency < -MAXIMUM_FREQUENCY ) if(mLoopFrequency < -MAXIMUM_FREQUENCY)
{ {
mLoopFrequency = -MAXIMUM_FREQUENCY; mLoopFrequency = -MAXIMUM_FREQUENCY;
} }
@@ -520,13 +544,13 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
* with the carrier frequency. Provides error feedback to adjust * with the carrier frequency. Provides error feedback to adjust
* mixer frequency. * mixer frequency.
*/ */
public float getPhaseError( Complex complex ) public float getPhaseError(Complex complex)
{ {
float phase_error = 0; float phase_error = 0;
if( Math.abs( complex.inphase() ) > Math.abs( complex.quadrature() ) ) if(Math.abs(complex.inphase()) > Math.abs(complex.quadrature()))
{ {
if( complex.inphase() > 0 ) if(complex.inphase() > 0)
{ {
phase_error = -complex.quadrature(); phase_error = -complex.quadrature();
} }
@@ -537,7 +561,7 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
} }
else else
{ {
if( complex.quadrature() > 0 ) if(complex.quadrature() > 0)
{ {
phase_error = complex.inphase(); phase_error = complex.inphase();
} }
@@ -554,33 +578,33 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
@Override @Override
public List<TapGroup> getTapGroups() public List<TapGroup> getTapGroups()
{ {
if( mAvailableTaps == null ) if(mAvailableTaps == null)
{ {
mAvailableTaps = new ArrayList<>(); mAvailableTaps = new ArrayList<>();
TapGroup group = new TapGroup( "LSM Demodulator" ); TapGroup group = new TapGroup("LSM Demodulator");
group.add( new EyeDiagramDataTap( "Eye Diagram", 0, 4800 ) ); group.add(new EyeDiagramDataTap("Eye Diagram", 0, 4800));
mAvailableTaps.add( group ); mAvailableTaps.add(group);
} }
return mAvailableTaps; return mAvailableTaps;
} }
@Override @Override
public void registerTap( Tap tap ) public void registerTap(Tap tap)
{ {
if( tap instanceof EyeDiagramDataTap ) if(tap instanceof EyeDiagramDataTap)
{ {
mEyeDiagramDataTap = (EyeDiagramDataTap)tap; mEyeDiagramDataTap = (EyeDiagramDataTap)tap;
} }
} }
@Override @Override
public void unregisterTap( Tap tap ) public void unregisterTap(Tap tap)
{ {
if( tap instanceof EyeDiagramDataTap ) if(tap instanceof EyeDiagramDataTap)
{ {
mEyeDiagramDataTap = null; mEyeDiagramDataTap = null;
} }

View File

@@ -0,0 +1,182 @@
/*******************************************************************************
* 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.psk.pll.IPhaseLockedLoop;
import io.github.dsheirer.dsp.symbol.Dibit;
import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.complex.Complex;
import io.github.dsheirer.sample.complex.ComplexBuffer;
import io.github.dsheirer.sample.complex.ComplexSampleListener;
public class QPSKDemodulator implements ComplexSampleListener
{
private InterpolatingSymbolBuffer mInterpolatingSymbolBuffer;
private IPhaseLockedLoop mPLL;
private ISymbolPhaseErrorCalculator mSymbolPhaseErrorCalculator;
private IQPSKSymbolDecoder mQPSKSymbolDecoder;
private GardnerDetector mGardnerDetector = new GardnerDetector();
private Listener<Complex> mSymbolListener;
private Listener<Double> mPLLErrorListener;
private Listener<Dibit> mDibitListener;
private Complex mPreviousSample = new Complex(0, 0);
private Complex mPreviousMiddleSample = new Complex(0, 0);
private Complex mCurrentSample = new Complex(0, 0);
private Complex mMiddleSample = new Complex(0, 0);
private Complex mPreviousSymbol = new Complex(0, 0);
private Complex mMiddleSymbol = new Complex(0, 0);
private Complex mCurrentSymbol = new Complex(0, 0);
private float mPhaseError;
private float mSymbolTimingError;
/**
* Decoder for Quaternary Phase Shift Keying (QPSK) and Differential QPSK (DQPSK). This decoder uses both a
* phase-locked loop and a gardner symbol timing error detector to automatically align to the incoming carrier
* frequency and to adjust for any changes in symbol timing.
*
* @param phaseLockedLoop for tracking carrier frequency error
* @param symbolPhaseErrorCalculator to calculate symbol phase errors and optionally adjust for differential encoding
* @param symbolDecoder to decode demodulated symbols into dibits
* @param sampleRate of the incoming complex sample stream
* @param symbolRate of the decoded QPSK symbols.
*/
public QPSKDemodulator(IPhaseLockedLoop phaseLockedLoop, ISymbolPhaseErrorCalculator symbolPhaseErrorCalculator,
IQPSKSymbolDecoder symbolDecoder, double sampleRate, double symbolRate)
{
if(sampleRate < (symbolRate * 2))
{
throw new IllegalArgumentException("Sample rate [" + sampleRate +
"] must be at least 2 x symbol rate [" + symbolRate + "]");
}
mPLL = phaseLockedLoop;
mSymbolPhaseErrorCalculator = symbolPhaseErrorCalculator;
mQPSKSymbolDecoder = symbolDecoder;
float samplesPerSymbol = (float)(sampleRate / symbolRate);
mInterpolatingSymbolBuffer = new InterpolatingSymbolBuffer(samplesPerSymbol);
}
/**
* Submits a buffer containing complex samples for decoding
* @param complexBuffer with complex samples
*/
public void receive(ComplexBuffer complexBuffer)
{
float[] samples = complexBuffer.getSamples();
for(int x = 0; x < samples.length; x += 2)
{
receive(samples[x], samples[x + 1]);
}
}
/**
* Submits a complex sample for decoding.
* @param inphase value for the sample
* @param quadrature value for the sample
*/
@Override
public void receive(float inphase, float quadrature)
{
//Update current sample with values
mCurrentSample.setValues(inphase, quadrature);
//Mix current sample with costas loop to remove any rotation that is present from a mis-tuned carrier frequency
mCurrentSample.multiply(mPLL.incrementAndGetCurrentVector());
mInterpolatingSymbolBuffer.receive(mCurrentSample);
//Calculate the symbol once we've stored enough samples
if(mInterpolatingSymbolBuffer.hasSymbol())
{
//Get middle and current samples from the interpolating buffer
mMiddleSample = mInterpolatingSymbolBuffer.getMiddleSample();
mCurrentSample = mInterpolatingSymbolBuffer.getCurrentSample();
//Calculate middle and current symbols as the delta between the previous and current samples
mMiddleSymbol.setInphase(Complex.multiplyInphase(mMiddleSample.inphase(), mMiddleSample.quadrature(), mPreviousMiddleSample.inphase(), -mPreviousMiddleSample.quadrature()));
mMiddleSymbol.setQuadrature(Complex.multiplyQuadrature(mMiddleSample.inphase(), mMiddleSample.quadrature(), mPreviousMiddleSample.inphase(), -mPreviousMiddleSample.quadrature()));
mCurrentSymbol.setInphase(Complex.multiplyInphase(mCurrentSample.inphase(), mCurrentSample.quadrature(), mPreviousSample.inphase(), -mPreviousSample.quadrature()));
mCurrentSymbol.setQuadrature(Complex.multiplyQuadrature(mCurrentSample.inphase(), mCurrentSample.quadrature(), mPreviousSample.inphase(), -mPreviousSample.quadrature()));
//Set gain to unity before we calculate the error value
mMiddleSymbol.normalize();
mCurrentSymbol.normalize();
//Symbol timing error calculations
mSymbolTimingError = mGardnerDetector.getError(mPreviousSymbol, mMiddleSymbol, mCurrentSymbol);
mInterpolatingSymbolBuffer.resetAndAdjust(mSymbolTimingError);
//Store current samples/symbols to use for the next period
mPreviousSample.setValues(mCurrentSample);
mPreviousMiddleSample.setValues(mMiddleSample);
mPreviousSymbol.setValues(mCurrentSymbol);
//Adjust the current symbol as necessary (e.g. for differential encoding)
mSymbolPhaseErrorCalculator.adjust(mCurrentSymbol);
//Calculate the phase error of the current symbol relative to the expected constellation and provide
//feedback to the PLL
mPhaseError = mSymbolPhaseErrorCalculator.getPhaseError(mCurrentSymbol);
mPLL.adjust(mPhaseError);
if(mPLLErrorListener != null)
{
mPLLErrorListener.receive((double)mPhaseError);
}
//Decode the dibit from the symbol and send to the listener
if(mDibitListener != null)
{
mDibitListener.receive(mQPSKSymbolDecoder.decode(mCurrentSymbol));
}
//Send to an external constellation symbol listener when registered
if(mSymbolListener != null)
{
mSymbolListener.receive(mCurrentSymbol);
}
//TODO: Assemble dibits here and broadcast
}
}
/**
* Registers the listener to receive decoded QPSK symbols
*/
public void setSymbolListener(Listener<Complex> listener)
{
mSymbolListener = listener;
}
/**
* Registers the listener to receive decoded QPSK dibits
*/
public void setDibitListener(Listener<Dibit> listener)
{
mDibitListener = listener;
}
/**
* Registers the listener to receive PLL error values
*/
public void setPLLErrorListener(Listener<Double> listener)
{
mPLLErrorListener = listener;
}
}

View File

@@ -1,3 +1,18 @@
/*******************************************************************************
* 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; package io.github.dsheirer.dsp.psk;
import io.github.dsheirer.dsp.symbol.Dibit; import io.github.dsheirer.dsp.symbol.Dibit;
@@ -5,24 +20,7 @@ import io.github.dsheirer.sample.Broadcaster;
import io.github.dsheirer.sample.Listener; import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.complex.Complex; import io.github.dsheirer.sample.complex.Complex;
/******************************************************************************* public class QPSKSymbolDecoder implements Listener<Complex>, IQPSKSymbolDecoder
* SDR Trunk
* Copyright (C) 2014,2015 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/>
******************************************************************************/
public class QPSKPolarSlicer implements Listener<Complex>
{ {
private Broadcaster<Dibit> mBroadcaster = new Broadcaster<Dibit>(); private Broadcaster<Dibit> mBroadcaster = new Broadcaster<Dibit>();
@@ -37,7 +35,7 @@ public class QPSKPolarSlicer implements Listener<Complex>
* / \ * / \
* / 11 \ * / 11 \
*/ */
public QPSKPolarSlicer() public QPSKSymbolDecoder()
{ {
} }
@@ -60,10 +58,10 @@ public class QPSKPolarSlicer implements Listener<Complex>
@Override @Override
public void receive( Complex complex ) public void receive( Complex complex )
{ {
mBroadcaster.broadcast( decide( complex ) ); mBroadcaster.broadcast( decode( complex ) );
} }
public static Dibit decide( Complex complex ) public Dibit decode(Complex complex )
{ {
if( Math.abs( complex.inphase() ) > Math.abs( complex.quadrature() ) ) if( Math.abs( complex.inphase() ) > Math.abs( complex.quadrature() ) )
{ {

View File

@@ -0,0 +1,63 @@
/*******************************************************************************
* 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;
/**
* Calculates the phase error for a QPSK polar-orientation constellation
*/
public class QPSKSymbolPhaseErrorCalculator implements ISymbolPhaseErrorCalculator
{
private float mPhaseError;
@Override
public void adjust(Complex symbol)
{
//No-op - since there is no differential, we don't have to adjust
}
@Override
public float getPhaseError(Complex symbol)
{
mPhaseError = 0.0f;
if(Math.abs(symbol.inphase()) > Math.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;
}
}

View File

@@ -0,0 +1,35 @@
/*******************************************************************************
* 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;
public enum SymbolInversion
{
DEGREES_90_PLUS(Math.PI / 2.0),
DEGREES_90_MINUS(Math.PI / -2.0),
DEGREES_180(Math.PI);
private double mAngleRadians;
SymbolInversion(double angleRadians)
{
mAngleRadians = angleRadians;
}
public double getError()
{
return mAngleRadians;
}
}

View File

@@ -0,0 +1,337 @@
/*******************************************************************************
* 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.pll;
import io.github.dsheirer.buffer.DoubleCircularBuffer;
import io.github.dsheirer.dsp.mixer.Oscillator;
import io.github.dsheirer.sample.complex.Complex;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.text.DecimalFormat;
/**
* Costas Loop - phase locked loop designed to automatically synchronize to the incoming carrier frequency in order to
* zeroize any frequency offset inherent in the signal due to either mis-tuning or carrier frequency drift.
*
* Costas loop structure was modeled from KA1RBI's OP25/cqpsk.py
*
* Loop bandwidth and alpha/beta gain formulas derived from:
* http://www.trondeau.com/blog/2011/8/13/control-loop-gain-values.html
*/
public class CostasLoop implements IPhaseLockedLoop
{
private final static Logger mLog = LoggerFactory.getLogger(CostasLoop.class);
public static final double TWO_PI = 2.0 * Math.PI;
private DoubleCircularBuffer mErrorBuffer = new DoubleCircularBuffer(10);
private double mDamping = Math.sqrt(2.0) / 2.0;
private double mAlphaGain;
private double mBetaGain;
private double mLoopPhase = 0.0;
private double mLoopFrequency = 0.0;
private double mMaximumLoopFrequency;
private Complex mCurrentVector = new Complex(0, 0);
private Tracking mTracking = Tracking.SEARCHING;
private ITrackingStateListener mTrackingStateListener;
private boolean mAutomaticTrackingEnabled = true;
/**
* Costas Loop for tracking and correcting frequency error in a received carrier signal.
*
* @param sampleRate of the incoming samples
* @param symbolRate of the digital signal
*/
public CostasLoop(double sampleRate, double symbolRate)
{
mMaximumLoopFrequency = TWO_PI * (symbolRate / 2.0) / sampleRate;
updateLoopBandwidth();
}
/**
* Corrects the current phase tracker when an inverted output is detected. The inversion will take the form of
* +/- 90 degrees or +/- 180 degrees, although the latter correction is equal regardless of the sign.
*
* If the supplied correction value places the loop frequency outside of the max frequency, then the frequency will
* be corrected 360 degrees in the opposite direction to maintain within the max frequency bounds.
*
* @param correction as measured in radians
*/
public void correctInversion(double correction)
{
mLoopFrequency += correction;
if(mLoopFrequency > mMaximumLoopFrequency)
{
mLoopFrequency -= 2.0 * mMaximumLoopFrequency;
}
if(mLoopFrequency < -mMaximumLoopFrequency)
{
mLoopFrequency += 2.0 * mMaximumLoopFrequency;
}
}
/**
* Updates the loop bandwidth and alpha/beta gains according to the current loop synchronization state.
*/
private void updateLoopBandwidth()
{
double bandwidth = TWO_PI / mTracking.getLoopBandwidth();
mAlphaGain = (4.0 * mDamping * bandwidth) / (1.0 + (2.0 * mDamping * bandwidth) + (bandwidth * bandwidth));
mBetaGain = (4.0 * bandwidth * bandwidth) / (1.0 + (2.0 * mDamping * bandwidth) + (bandwidth * bandwidth));
}
/**
* Sets the tracking state for this costas loop. The tracking state affects the aggressiveness of the alpha/beta
* gain values in synchronizing with the signal carrier.
*
* @param tracking
*/
public void setTracking(Tracking tracking)
{
mTracking = tracking;
updateLoopBandwidth();
mLog.debug("Tracking: " + tracking.name());
if(mTrackingStateListener != null)
{
mTrackingStateListener.trackingStateChanged(tracking);
}
}
/**
* Sets the listener to receive notifications when the tracking state changes
*/
public void setTrackingStateListener(ITrackingStateListener listener)
{
mTrackingStateListener = listener;
}
/**
* Enables or disables automatic tracking state updates. When enabled, the loop will automatically increase or
* decrease the loop alpha/beta gain values based on the variance of the error tracking values submitted to the
* loop control. As the variance decreases, so will the gain values, and vice-versa. Setting this to disabled
* will force the tracker to retain the gain values associated with either the default or user-specified tracking
* value.
*
* @param enabled true (default) to enable automatic gain tracking
*/
public void setAutomaticTracking(boolean enabled)
{
mAutomaticTrackingEnabled = enabled;
}
/**
* Increments the phase of the loop for each sample received at the sample rate.
*/
public void increment()
{
mLoopPhase += mLoopFrequency;
/* Keep the loop phase in bounds */
normalizePhase();
}
/**
* Current vector of the loop. Note: this value is updated for the current angle in radians each time this method
* is invoked.
*/
public Complex getCurrentVector()
{
mCurrentVector.setAngle(mLoopPhase);
return mCurrentVector;
}
@Override
public Complex incrementAndGetCurrentVector()
{
increment();
return getCurrentVector();
}
public double getLoopFrequency()
{
return mLoopFrequency;
}
public double getMaximumLoopFrequency()
{
return mMaximumLoopFrequency;
}
/**
* Updates the costas loop frequency and phase to adjust for the phase
* error value
*
* @param phaseError - (-)= late and (+)= early
*/
public void adjust(double phaseError)
{
mLoopFrequency += (mBetaGain * phaseError);
mLoopPhase += mLoopFrequency + (mAlphaGain * phaseError);
/* Maintain phase between +/- 2 * PI */
normalizePhase();
/* Limit frequency to +/- maximum loop frequency */
limitFrequency();
mErrorBuffer.put(phaseError);
double variance = mErrorBuffer.variance();
switch(mTracking)
{
case SEARCHING:
if(Tracking.COARSE.meetsThreshold(variance))
{
setTracking(Tracking.COARSE);
}
break;
case COARSE:
if(Tracking.COARSE.meetsThreshold(variance))
{
if(Tracking.FINE.meetsThreshold(variance))
{
setTracking(Tracking.FINE);
}
}
else
{
setTracking(Tracking.SEARCHING);
}
break;
case FINE:
if(Tracking.FINE.meetsThreshold(variance))
{
if(Tracking.LOCKED.meetsThreshold(variance))
{
setTracking(Tracking.LOCKED);
}
}
else
{
setTracking(Tracking.COARSE);
}
break;
case LOCKED:
if(!Tracking.LOCKED.meetsThreshold(variance))
{
setTracking(Tracking.FINE);
}
break;
}
}
public double getErrorMean()
{
return mErrorBuffer.mean();
}
public double getErrorVariance()
{
return mErrorBuffer.variance();
}
/**
* Normalizes the phase tracker to maintain within +/- 2 Pi
*/
private void normalizePhase()
{
while(mLoopPhase > TWO_PI)
{
mLoopPhase -= TWO_PI;
}
while(mLoopPhase < -TWO_PI)
{
mLoopPhase += TWO_PI;
}
}
/**
* Constrains the frequency within the bounds of +/- loop frequency
*/
private void limitFrequency()
{
if(mLoopFrequency > mMaximumLoopFrequency)
{
mLoopFrequency = mMaximumLoopFrequency;
}
if(mLoopFrequency < -mMaximumLoopFrequency)
{
mLoopFrequency = -mMaximumLoopFrequency;
}
}
/**
* Tracking state listener interface for receiving updates when the tracking state of the costas loop changes
*/
public interface ITrackingStateListener
{
void trackingStateChanged(Tracking tracking);
}
public static void main(String[] arguments)
{
DecimalFormat decimalFormat = new DecimalFormat("0.000000");
double sampleRate = 25000.0;
int errorFrequency = 411;
double loopBandwidth = 50.0;
Oscillator oscillator = new Oscillator(errorFrequency, (int)sampleRate);
CostasLoop costasLoop = new CostasLoop(sampleRate, 4800.0);
costasLoop.setTrackingStateListener(new ITrackingStateListener()
{
@Override
public void trackingStateChanged(Tracking tracking)
{
mLog.debug("Tracking State Changed: " + tracking.name());
}
});
for(int x = 0; x < 1000; x++)
{
Complex complex = oscillator.getComplex();
oscillator.rotate();
costasLoop.increment();
if(x % 5 == 0)
{
complex.multiply(costasLoop.getCurrentVector().conjugate());
double phaseError = complex.angle();
costasLoop.adjust(phaseError);
double loopFrequency = costasLoop.getLoopFrequency() * sampleRate / TWO_PI;
double maxFrequency = costasLoop.getMaximumLoopFrequency() * sampleRate / TWO_PI;
mLog.debug(x + " Frequency: " + errorFrequency +
" Loop:" + decimalFormat.format(loopFrequency) +
" Max:" + maxFrequency +
" Detected Error:" + decimalFormat.format(phaseError) +
" Avg:" + decimalFormat.format(costasLoop.getErrorMean()) +
" Var:" + decimalFormat.format(costasLoop.getErrorVariance()));
}
}
}
}

View File

@@ -0,0 +1,56 @@
/*******************************************************************************
* 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.pll;
import io.github.dsheirer.sample.complex.Complex;
/**
* Phase-Locked Loop (PLL) interface
*/
public interface IPhaseLockedLoop
{
/**
* Increments the PLL by one sample period
*/
void increment();
/**
* Applies an error value to the PLL.
*
* @param error value in the range of -PI <> +PI
*/
void adjust(double error);
/**
* Adjusts the current phase of the loop to account for +/-90 or 180 degree inverted phase locks when detected
* @param correction to apply to the phase of the loop
*/
void correctInversion(double correction);
/**
* Current vector of the PLL to use in de-spinning the incoming samples.
* @return complex vector
*/
Complex getCurrentVector();
/**
* Increments the phase rotation and gets the current vector of the PLL to use in de-spinning the incoming samples.
* @return complex vector
*/
Complex incrementAndGetCurrentVector();
}

View File

@@ -0,0 +1,48 @@
/*******************************************************************************
* 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.pll;
public enum Tracking
{
SEARCHING(50.0, Math.PI),
COARSE(100.0, 0.01),
FINE(150.0, 0.001),
LOCKED(200.0, 0.0001);
private double mLoopBandwidth;
private double mVarianceThreshold;
Tracking(double loopBandwidth, double varianceThreshold)
{
mLoopBandwidth = loopBandwidth;
mVarianceThreshold = varianceThreshold;
}
public double getLoopBandwidth()
{
return mLoopBandwidth;
}
public double getVarianceThreshold()
{
return mVarianceThreshold;
}
public boolean meetsThreshold(double variance)
{
return variance < getVarianceThreshold();
}
}

View File

@@ -15,6 +15,8 @@
******************************************************************************/ ******************************************************************************/
package io.github.dsheirer.instrument.gui.viewer; package io.github.dsheirer.instrument.gui.viewer;
import io.github.dsheirer.instrument.gui.viewer.decoder.DecoderPaneFactory;
import io.github.dsheirer.module.decode.DecoderType;
import javafx.application.Application; import javafx.application.Application;
import javafx.application.Platform; import javafx.application.Platform;
import javafx.event.ActionEvent; import javafx.event.ActionEvent;
@@ -44,7 +46,7 @@ public class DemodulatorViewerFX extends Application
public void start(Stage primaryStage) throws Exception public void start(Stage primaryStage) throws Exception
{ {
mStage = primaryStage; mStage = primaryStage;
mStage.setTitle("Demodulator Viewer FX"); setTitle(null);
BorderPane borderPane = new BorderPane(); BorderPane borderPane = new BorderPane();
borderPane.setTop(getMenuBar()); borderPane.setTop(getMenuBar());
@@ -56,6 +58,18 @@ public class DemodulatorViewerFX extends Application
mStage.show(); mStage.show();
} }
private void setTitle(DecoderType decoderType)
{
if(decoderType != null)
{
mStage.setTitle("Demodulator Viewer FX - " + decoderType.getDisplayString());
}
else
{
mStage.setTitle("Demodulator Viewer FX");
}
}
private ViewerDesktop getViewerDesktop() private ViewerDesktop getViewerDesktop()
{ {
if(mViewerDesktop == null) if(mViewerDesktop == null)
@@ -72,9 +86,9 @@ public class DemodulatorViewerFX extends Application
{ {
mMenuBar = new MenuBar(); mMenuBar = new MenuBar();
Menu menuFile = new Menu("File"); Menu fileMenu = new Menu("File");
MenuItem menuItemOpen = new MenuItem("Open ..."); MenuItem openMenuItem = new MenuItem("Open ...");
menuItemOpen.setOnAction(new EventHandler<ActionEvent>() openMenuItem.setOnAction(new EventHandler<ActionEvent>()
{ {
@Override @Override
public void handle(ActionEvent event) public void handle(ActionEvent event)
@@ -87,8 +101,8 @@ public class DemodulatorViewerFX extends Application
} }
}); });
MenuItem menuItemClose = new MenuItem("Close"); MenuItem closeMenuItem = new MenuItem("Close");
menuItemClose.setOnAction(new EventHandler<ActionEvent>() closeMenuItem.setOnAction(new EventHandler<ActionEvent>()
{ {
@Override @Override
public void handle(ActionEvent event) public void handle(ActionEvent event)
@@ -97,8 +111,8 @@ public class DemodulatorViewerFX extends Application
} }
}); });
MenuItem menuItemExit = new MenuItem("Exit"); MenuItem exitMenuItem = new MenuItem("Exit");
menuItemExit.setOnAction(new EventHandler<ActionEvent>() exitMenuItem.setOnAction(new EventHandler<ActionEvent>()
{ {
@Override @Override
public void handle(ActionEvent event) public void handle(ActionEvent event)
@@ -107,10 +121,34 @@ public class DemodulatorViewerFX extends Application
} }
}); });
menuFile.getItems().addAll(menuItemOpen, getRecentFilesMenu(), menuItemClose, new SeparatorMenuItem(), fileMenu.getItems().addAll(openMenuItem, getRecentFilesMenu(), closeMenuItem, new SeparatorMenuItem(),
menuItemExit); exitMenuItem);
mMenuBar.getMenus().addAll(menuFile); mMenuBar.getMenus().add(fileMenu);
Menu decoderMenu = new Menu("Decoder");
for(DecoderType decoderType: DecoderType.values())
{
if(DecoderPaneFactory.isSupported(decoderType))
{
MenuItem decoderMenuItem = new MenuItem(decoderType.getShortDisplayString());
decoderMenuItem.setOnAction(new EventHandler<ActionEvent>()
{
@Override
public void handle(ActionEvent event)
{
getViewerDesktop().setDecoder(decoderType);
setTitle(decoderType);
}
});
decoderMenu.getItems().add(decoderMenuItem);
}
}
mMenuBar.getMenus().add(decoderMenu);
} }
return mMenuBar; return mMenuBar;

View File

@@ -15,6 +15,7 @@
******************************************************************************/ ******************************************************************************/
package io.github.dsheirer.instrument.gui.viewer; package io.github.dsheirer.instrument.gui.viewer;
import io.github.dsheirer.instrument.gui.viewer.decoder.DecoderPane;
import io.github.dsheirer.sample.Broadcaster; import io.github.dsheirer.sample.Broadcaster;
import io.github.dsheirer.sample.Listener; import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.complex.ComplexBuffer; import io.github.dsheirer.sample.complex.ComplexBuffer;
@@ -52,6 +53,7 @@ public class PlaybackController extends HBox implements IFrameLocationListener,
private HBox mControlsBox; private HBox mControlsBox;
private Label mFileLabel; private Label mFileLabel;
private EventHandler<ActionEvent> mPlayEventHandler; private EventHandler<ActionEvent> mPlayEventHandler;
private DecoderPane mSampleRateListener;
private IControllableFileSource mControllableFileSource; private IControllableFileSource mControllableFileSource;
private Broadcaster<ComplexBuffer> mComplexBufferBroadcaster = new Broadcaster<>(); private Broadcaster<ComplexBuffer> mComplexBufferBroadcaster = new Broadcaster<>();
@@ -65,6 +67,16 @@ public class PlaybackController extends HBox implements IFrameLocationListener,
setControlsEnabled(false); setControlsEnabled(false);
} }
public void setSampleRateListener(DecoderPane decoderPane)
{
mSampleRateListener = decoderPane;
if(mSampleRateListener != null && mControllableFileSource != null)
{
mSampleRateListener.setSampleRate(mControllableFileSource.getSampleRate());
}
}
public void load(File file) public void load(File file)
{ {
mLog.debug("loading:" + file.getAbsolutePath()); mLog.debug("loading:" + file.getAbsolutePath());
@@ -76,6 +88,11 @@ public class PlaybackController extends HBox implements IFrameLocationListener,
mControllableFileSource.setListener(this); mControllableFileSource.setListener(this);
((ComplexWaveSource)mControllableFileSource).setListener((Listener<ComplexBuffer>)this); ((ComplexWaveSource)mControllableFileSource).setListener((Listener<ComplexBuffer>)this);
mControllableFileSource.open(); mControllableFileSource.open();
if(mSampleRateListener != null)
{
mSampleRateListener.setSampleRate(mControllableFileSource.getSampleRate());
}
} }
catch(UnsupportedAudioFileException e) catch(UnsupportedAudioFileException e)
{ {

View File

@@ -15,25 +15,22 @@
******************************************************************************/ ******************************************************************************/
package io.github.dsheirer.instrument.gui.viewer; package io.github.dsheirer.instrument.gui.viewer;
import io.github.dsheirer.instrument.gui.viewer.decoder.DecoderPane;
import io.github.dsheirer.instrument.gui.viewer.decoder.DecoderPaneFactory;
import io.github.dsheirer.module.decode.DecoderType;
import javafx.scene.layout.BorderPane; import javafx.scene.layout.BorderPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;
import java.io.File; import java.io.File;
public class ViewerDesktop extends BorderPane public class ViewerDesktop extends BorderPane
{ {
private PlaybackController mPlaybackController; private PlaybackController mPlaybackController;
private VBox mChartBox; private DecoderPane mDecoderPane = DecoderPaneFactory.getDefaultPane();
private ComplexSampleLineChart mSampleLineChart;
private ComplexPhaseLineChart mPhaseLineChart;
public ViewerDesktop() public ViewerDesktop()
{ {
setBottom(getPlaybackController()); setBottom(getPlaybackController());
getPlaybackController().addListener(getSampleLineChart()); setCenter(getDecoderPane());
getPlaybackController().addListener(getPhaseLineChart());
setCenter(getChartBox());
} }
public void load(File file) public void load(File file)
@@ -42,6 +39,31 @@ public class ViewerDesktop extends BorderPane
getPlaybackController().load(file); getPlaybackController().load(file);
} }
public void setDecoder(DecoderType decoderType)
{
getPlaybackController().removeListener(getDecoderPane());
getChildren().remove(getDecoderPane());
mDecoderPane = DecoderPaneFactory.getDecoderPane(decoderType);
setCenter(getDecoderPane());
getPlaybackController().addListener(getDecoderPane());
getPlaybackController().setSampleRateListener(getDecoderPane());
}
/**
* Decoder pane
*/
public DecoderPane getDecoderPane()
{
if(mDecoderPane == null)
{
mDecoderPane = DecoderPaneFactory.getDefaultPane();
}
return mDecoderPane;
}
public void close() public void close()
{ {
getPlaybackController().close(); getPlaybackController().close();
@@ -56,35 +78,4 @@ public class ViewerDesktop extends BorderPane
return mPlaybackController; return mPlaybackController;
} }
private VBox getChartBox()
{
if(mChartBox == null)
{
mChartBox = new VBox();
mChartBox.getChildren().addAll(getSampleLineChart(), getPhaseLineChart());
}
return mChartBox;
}
private ComplexSampleLineChart getSampleLineChart()
{
if(mSampleLineChart == null)
{
mSampleLineChart = new ComplexSampleLineChart(40);
}
return mSampleLineChart;
}
private ComplexPhaseLineChart getPhaseLineChart()
{
if(mPhaseLineChart == null)
{
mPhaseLineChart = new ComplexPhaseLineChart(50);
}
return mPhaseLineChart;
}
} }

View File

@@ -13,7 +13,7 @@
* If not, see <http://www.gnu.org/licenses/> * If not, see <http://www.gnu.org/licenses/>
* *
******************************************************************************/ ******************************************************************************/
package io.github.dsheirer.instrument.gui.viewer; package io.github.dsheirer.instrument.gui.viewer.chart;
import io.github.dsheirer.buffer.ComplexCircularBuffer; import io.github.dsheirer.buffer.ComplexCircularBuffer;
import io.github.dsheirer.dsp.gain.ComplexGain; import io.github.dsheirer.dsp.gain.ComplexGain;
@@ -28,7 +28,6 @@ import javafx.collections.FXCollections;
import javafx.collections.ObservableList; import javafx.collections.ObservableList;
import javafx.scene.chart.LineChart; import javafx.scene.chart.LineChart;
import javafx.scene.chart.NumberAxis; import javafx.scene.chart.NumberAxis;
import org.apache.commons.math3.complex.ComplexUtils;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@@ -36,7 +35,7 @@ public class ComplexPhaseLineChart extends LineChart implements Listener<Complex
{ {
private final static Logger mLog = LoggerFactory.getLogger(ComplexPhaseLineChart.class); private final static Logger mLog = LoggerFactory.getLogger(ComplexPhaseLineChart.class);
private static final Complex ANGLE_OFFSET_45_DEGREES = Complex.fromAngle((float)(Math.PI / 4.0)); private static final Complex ANGLE_OFFSET_45_DEGREES = Complex.fromAngle(Math.PI / 4.0);
private ComplexCircularBuffer mComplexCircularBuffer; private ComplexCircularBuffer mComplexCircularBuffer;
private ComplexGain mComplexGain = new ComplexGain(600.0f); private ComplexGain mComplexGain = new ComplexGain(600.0f);
private ObservableList<Data<Integer,Float>> mPhaseValues = FXCollections.observableArrayList(); private ObservableList<Data<Integer,Float>> mPhaseValues = FXCollections.observableArrayList();
@@ -44,8 +43,8 @@ public class ComplexPhaseLineChart extends LineChart implements Listener<Complex
public ComplexPhaseLineChart(int length) public ComplexPhaseLineChart(int length)
{ {
super(new NumberAxis("Time", 1, length - 10, 1), super(new NumberAxis("Time", 1, length - 10, 2),
new NumberAxis("Phase", -Math.PI, Math.PI, 1.0)); new NumberAxis("Phase", -Math.PI, Math.PI, Math.PI / 2.0));
Series<Integer,Float> phaseSeries = new Series<>("Phase", mPhaseValues); Series<Integer,Float> phaseSeries = new Series<>("Phase", mPhaseValues);
ObservableList<Series<Integer,Float>> observableList = FXCollections.observableArrayList(phaseSeries); ObservableList<Series<Integer,Float>> observableList = FXCollections.observableArrayList(phaseSeries);

View File

@@ -13,7 +13,7 @@
* If not, see <http://www.gnu.org/licenses/> * If not, see <http://www.gnu.org/licenses/>
* *
******************************************************************************/ ******************************************************************************/
package io.github.dsheirer.instrument.gui.viewer; package io.github.dsheirer.instrument.gui.viewer.chart;
import io.github.dsheirer.buffer.ComplexCircularBuffer; import io.github.dsheirer.buffer.ComplexCircularBuffer;
import io.github.dsheirer.dsp.gain.ComplexGain; import io.github.dsheirer.dsp.gain.ComplexGain;
@@ -44,8 +44,8 @@ public class ComplexSampleLineChart extends LineChart implements Listener<Comple
public ComplexSampleLineChart(int length) public ComplexSampleLineChart(int length)
{ {
super(new NumberAxis("Sample Number", 1, length, 1), super(new NumberAxis("Sample Number", 1, length, 2),
new NumberAxis("Value", -1.0, 1.0, 0.1)); new NumberAxis("Value", -1.0, 1.0, 0.25));
LineChart.Series<Integer,Float> iSampleSeries = new LineChart.Series<>("Inphase", mISamples); LineChart.Series<Integer,Float> iSampleSeries = new LineChart.Series<>("Inphase", mISamples);
LineChart.Series<Integer,Float> qSampleSeries = new LineChart.Series<>("Quadrature", mQSamples); LineChart.Series<Integer,Float> qSampleSeries = new LineChart.Series<>("Quadrature", mQSamples);

View File

@@ -0,0 +1,73 @@
/*******************************************************************************
* 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.instrument.gui.viewer.chart;
import io.github.dsheirer.buffer.DoubleCircularBuffer;
import io.github.dsheirer.sample.Listener;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.scene.chart.LineChart;
import javafx.scene.chart.NumberAxis;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class PhaseLineChart extends LineChart implements Listener<Double>
{
private final static Logger mLog = LoggerFactory.getLogger(PhaseLineChart.class);
private DoubleCircularBuffer mDoubleCircularBuffer;
private ObservableList<Data<Integer,Double>> mPhaseValues = FXCollections.observableArrayList();
public PhaseLineChart(int length)
{
super(new NumberAxis("Time", 1, length, 2),
new NumberAxis("Phase", -Math.PI, Math.PI, Math.PI / 2.0));
Series<Integer,Double> phaseSeries = new Series<>("Phase", mPhaseValues);
ObservableList<Series<Integer,Double>> observableList = FXCollections.observableArrayList(phaseSeries);
setData(observableList);
init(length);
}
private void init(int length)
{
mDoubleCircularBuffer = new DoubleCircularBuffer(length);
for(int x = 1; x <= length; x++)
{
mPhaseValues.add(new Data(x, 0.0));
}
}
@Override
public void receive(Double phase)
{
mDoubleCircularBuffer.put(phase);
updateChart();
}
private void updateChart()
{
double[] values = mDoubleCircularBuffer.getAll();
for(int x = 0; x < values.length; x++)
{
mPhaseValues.get(x).setYValue(values[x]);
}
}
}

View File

@@ -0,0 +1,90 @@
/*******************************************************************************
* 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.instrument.gui.viewer.chart;
import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.complex.Complex;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.scene.chart.NumberAxis;
import javafx.scene.chart.ScatterChart;
import javafx.scene.chart.XYChart;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SymbolChart extends ScatterChart implements Listener<Complex>
{
private final static Logger mLog = LoggerFactory.getLogger(SymbolChart.class);
private ObservableList<ScatterChart.Data> mCurrentPoints = FXCollections.observableArrayList();
private ObservableList<ScatterChart.Data> mPreviousPoints = FXCollections.observableArrayList();
private ObservableList<ScatterChart.Data> mOldestPoints = FXCollections.observableArrayList();
private int mDataPointer;
private int mHistory;
/**
* Symbol chart for plotting a series of constellation symbols over time. Maintains three history sets for
* current, previous, and oldest symbols.
*
* @param history size for each of the history sets
*/
public SymbolChart(int history)
{
super(new NumberAxis("I", -1.0, 1.0, 0.2),
new NumberAxis("Q", -1.0, 1.0, 0.2));
mHistory = history;
for(int x = 0; x < mHistory; x++)
{
mCurrentPoints.add(new XYChart.Data<>(0.0, 0.0));
mPreviousPoints.add(new XYChart.Data<>(0.0, 0.0));
mOldestPoints.add(new XYChart.Data<>(0.0, 0.0));
}
ObservableList<XYChart.Series> data = FXCollections.observableArrayList();
data.add(new ScatterChart.Series("Current", mCurrentPoints));
data.add(new ScatterChart.Series("Previous", mPreviousPoints));
data.add(new ScatterChart.Series("Oldest", mOldestPoints));
this.setData(data);
}
@Override
public void receive(Complex complex)
{
//Transfer previous to oldest
XYChart.Data oldest = mOldestPoints.get(mDataPointer);
XYChart.Data previous = mPreviousPoints.get(mDataPointer);
XYChart.Data current = mCurrentPoints.get(mDataPointer);
oldest.setXValue(previous.getXValue());
oldest.setYValue(previous.getYValue());
previous.setXValue(current.getXValue());
previous.setYValue(current.getYValue());
current.setXValue(complex.inphase());
current.setYValue(complex.quadrature());
mDataPointer++;
if(mDataPointer >= mHistory)
{
mDataPointer = 0;
}
}
}

View File

@@ -0,0 +1,62 @@
/*******************************************************************************
* 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.instrument.gui.viewer.decoder;
import io.github.dsheirer.module.decode.DecoderType;
import io.github.dsheirer.sample.Broadcaster;
import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.complex.ComplexBuffer;
import javafx.scene.layout.VBox;
import javafx.scene.text.Text;
public class DecoderPane extends VBox implements Listener<ComplexBuffer>
{
private Broadcaster<ComplexBuffer> mComplexBufferBroadcaster = new Broadcaster<>();
private DecoderType mDecoderType;
public DecoderPane(DecoderType decoderType)
{
mDecoderType = decoderType;
}
/**
* Package private - used by factory class to create an empty pane
*/
DecoderPane()
{
getChildren().add(new Text("Please select a decoder from the menu"));
}
@Override
public void receive(ComplexBuffer complexBuffer)
{
mComplexBufferBroadcaster.broadcast(complexBuffer);
}
public void addListener(Listener<ComplexBuffer> listener)
{
mComplexBufferBroadcaster.addListener(listener);
}
public void removeListener(Listener<ComplexBuffer> listener)
{
mComplexBufferBroadcaster.removeListener(listener);
}
public void setSampleRate(double sampleRate)
{
}
}

View File

@@ -0,0 +1,55 @@
/*******************************************************************************
* 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.instrument.gui.viewer.decoder;
import io.github.dsheirer.module.decode.DecoderType;
import java.util.EnumSet;
public class DecoderPaneFactory
{
private static final EnumSet<DecoderType> SUPPORTED_DECODER_TYPES = EnumSet.of(DecoderType.P25_PHASE1);
/**
* Creates a decoder pane for the decoder type
*/
public static DecoderPane getDecoderPane(DecoderType decoderType)
{
switch(decoderType)
{
case P25_PHASE1:
return new P25Phase1Pane();
}
return getDefaultPane();
}
/**
* Creates an empty decoder pane
*/
public static DecoderPane getDefaultPane()
{
return new DecoderPane();
}
/**
* Indicates if the decoder type is supported by this factory
*/
public static boolean isSupported(DecoderType decoderType)
{
return SUPPORTED_DECODER_TYPES.contains(decoderType);
}
}

View File

@@ -0,0 +1,141 @@
/*******************************************************************************
* 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.instrument.gui.viewer.decoder;
import io.github.dsheirer.instrument.gui.viewer.chart.ComplexPhaseLineChart;
import io.github.dsheirer.instrument.gui.viewer.chart.ComplexSampleLineChart;
import io.github.dsheirer.instrument.gui.viewer.chart.PhaseLineChart;
import io.github.dsheirer.instrument.gui.viewer.chart.SymbolChart;
import io.github.dsheirer.module.decode.DecoderType;
import io.github.dsheirer.module.decode.p25.P25_C4FMDecoder2;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Priority;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class P25Phase1Pane extends DecoderPane
{
private final static Logger mLog = LoggerFactory.getLogger(P25Phase1Pane.class);
private HBox mSampleChartBox;
private ComplexSampleLineChart mSampleLineChart;
private ComplexPhaseLineChart mPhaseLineChart;
private HBox mDecoderChartBox;
private SymbolChart mSymbolChart;
private PhaseLineChart mPLLPhaseErrorLineChart;
private P25_C4FMDecoder2 mDecoder = new P25_C4FMDecoder2(null);
public P25Phase1Pane()
{
super(DecoderType.P25_PHASE1);
init();
}
private void init()
{
addListener(getSampleLineChart());
addListener(getPhaseLineChart());
addListener(getDecoder());
getDecoder().setSymbolListener(getSymbolChart());
getDecoder().setPLLPhaseErrorListener(getPLLPhaseErrorLineChart());
getChildren().addAll(getSampleChartBox(), getDecoderChartBox());
}
@Override
public void setSampleRate(double sampleRate)
{
mLog.debug("Configuring for sample rate: " + sampleRate);
mDecoder.setSampleRate(sampleRate);
}
private P25_C4FMDecoder2 getDecoder()
{
return mDecoder;
}
private SymbolChart getSymbolChart()
{
if(mSymbolChart == null)
{
mSymbolChart = new SymbolChart(20);
}
return mSymbolChart;
}
private HBox getDecoderChartBox()
{
if(mDecoderChartBox == null)
{
mDecoderChartBox = new HBox();
getSymbolChart().setMaxWidth(Double.MAX_VALUE);
getPLLPhaseErrorLineChart().setMaxWidth(Double.MAX_VALUE);
HBox.setHgrow(getSymbolChart(), Priority.ALWAYS);
HBox.setHgrow(getPLLPhaseErrorLineChart(), Priority.ALWAYS);
mDecoderChartBox.getChildren().addAll(getSymbolChart(), getPLLPhaseErrorLineChart());
}
return mDecoderChartBox;
}
private HBox getSampleChartBox()
{
if(mSampleChartBox == null)
{
mSampleChartBox = new HBox();
getSampleLineChart().setMaxWidth(Double.MAX_VALUE);
getPhaseLineChart().setMaxWidth(Double.MAX_VALUE);
HBox.setHgrow(getSampleLineChart(), Priority.ALWAYS);
HBox.setHgrow(getPhaseLineChart(), Priority.ALWAYS);
mSampleChartBox.getChildren().addAll(getSampleLineChart(), getPhaseLineChart());
}
return mSampleChartBox;
}
private ComplexSampleLineChart getSampleLineChart()
{
if(mSampleLineChart == null)
{
mSampleLineChart = new ComplexSampleLineChart(40);
}
return mSampleLineChart;
}
private ComplexPhaseLineChart getPhaseLineChart()
{
if(mPhaseLineChart == null)
{
mPhaseLineChart = new ComplexPhaseLineChart(50);
}
return mPhaseLineChart;
}
private PhaseLineChart getPLLPhaseErrorLineChart()
{
if(mPLLPhaseErrorLineChart == null)
{
mPLLPhaseErrorLineChart = new PhaseLineChart(80);
}
return mPLLPhaseErrorLineChart;
}
}

View File

@@ -22,10 +22,10 @@ import io.github.dsheirer.message.Message;
import io.github.dsheirer.module.Module; import io.github.dsheirer.module.Module;
import io.github.dsheirer.sample.Listener; import io.github.dsheirer.sample.Listener;
public abstract class Decoder extends Module public abstract class Decoder extends Module implements IMessageProvider
implements IMessageProvider, Listener<Message>
{ {
/* This has to be a broadcaster in order for references to persist */ /* This has to be a broadcaster in order for references to persist */
private Listener<Message> mMessageDistributor = new MessageDistributor();
protected Listener<Message> mMessageListener; protected Listener<Message> mMessageListener;
/** /**
@@ -51,7 +51,7 @@ public abstract class Decoder extends Module
* Adds a listener for receiving decoded messages from this decoder * Adds a listener for receiving decoded messages from this decoder
*/ */
@Override @Override
public void setMessageListener( Listener<Message> listener ) public void setMessageListener(Listener<Message> listener)
{ {
mMessageListener = listener; mMessageListener = listener;
} }
@@ -67,19 +67,25 @@ public abstract class Decoder extends Module
} }
/** /**
* Broadcasts the message to the registered message listener * Message listener for receiving the output from this decoder
*/ */
public void broadcast( Message message ) protected Listener<Message> getMessageListener()
{ {
if( mMessageListener != null ) return mMessageDistributor;
{
mMessageListener.receive( message );
}
} }
@Override /**
public void receive( Message message ) * Distributes/forwards messages from sub-class decoder implementations to the registered message listener.
*/
public class MessageDistributor implements Listener<Message>
{ {
broadcast( message ); @Override
public void receive(Message message)
{
if(mMessageListener != null)
{
mMessageListener.receive(message);
}
}
} }
} }

View File

@@ -90,7 +90,7 @@ public class Fleetsync2Decoder extends Decoder implements IFilteredRealBufferLis
mMessageProcessor = new Fleetsync2MessageProcessor( aliasList ); mMessageProcessor = new Fleetsync2MessageProcessor( aliasList );
mMessageFramer.addMessageListener( mMessageProcessor ); mMessageFramer.addMessageListener( mMessageProcessor );
mMessageProcessor.setMessageListener( this ); mMessageProcessor.setMessageListener( getMessageListener() );
} }
public void dispose() public void dispose()

View File

@@ -100,7 +100,7 @@ public class LJ1200Decoder extends Decoder implements IFilteredRealBufferListene
mMessageProcessor = new LJ1200MessageProcessor( aliasList ); mMessageProcessor = new LJ1200MessageProcessor( aliasList );
mTowerMessageFramer.addMessageListener( mMessageProcessor ); mTowerMessageFramer.addMessageListener( mMessageProcessor );
mTransponderMessageFramer.addMessageListener( mMessageProcessor ); mTransponderMessageFramer.addMessageListener( mMessageProcessor );
mMessageProcessor.setMessageListener( this ); mMessageProcessor.setMessageListener( getMessageListener() );
} }
@Override @Override

View File

@@ -74,7 +74,7 @@ public class LTRNetDecoder extends Decoder
mLTRMessageFramer.addMessageListener( mLTRMessageProcessor ); mLTRMessageFramer.addMessageListener( mLTRMessageProcessor );
mLTRMessageProcessor.setMessageListener( this ); mLTRMessageProcessor.setMessageListener( getMessageListener() );
} }
@Override @Override

View File

@@ -64,7 +64,7 @@ public class LTRStandardDecoder extends Decoder implements IUnFilteredRealBuffer
mLTRMessageProcessor = new LTRStandardMessageProcessor( direction, aliasList ); mLTRMessageProcessor = new LTRStandardMessageProcessor( direction, aliasList );
mLTRMessageFramer.addMessageListener( mLTRMessageProcessor ); mLTRMessageFramer.addMessageListener( mLTRMessageProcessor );
mLTRMessageProcessor.setMessageListener( this ); mLTRMessageProcessor.setMessageListener( getMessageListener() );
} }
@Override @Override

View File

@@ -102,7 +102,7 @@ public class MDCDecoder extends Decoder implements IFilteredRealBufferListener,
/* Message Processor */ /* Message Processor */
mMessageProcessor = new MDCMessageProcessor( aliasList ); mMessageProcessor = new MDCMessageProcessor( aliasList );
mMessageFramer.addMessageListener( mMessageProcessor ); mMessageFramer.addMessageListener( mMessageProcessor );
mMessageProcessor.addMessageListener( this ); mMessageProcessor.addMessageListener(getMessageListener());
} }
public void dispose() public void dispose()

View File

@@ -148,7 +148,7 @@ public class MPT1327Decoder extends Decoder implements IFilteredRealBufferListen
/* Fully decoded and framed messages processor */ /* Fully decoded and framed messages processor */
mMessageProcessor = new MPT1327MessageProcessor(aliasList); mMessageProcessor = new MPT1327MessageProcessor(aliasList);
mMessageProcessor.setMessageListener(this); mMessageProcessor.setMessageListener(getMessageListener());
mControlMessageFramer.addMessageListener(mMessageProcessor); mControlMessageFramer.addMessageListener(mMessageProcessor);
mTrafficMessageFramer.addMessageListener(mMessageProcessor); mTrafficMessageFramer.addMessageListener(mMessageProcessor);
} }

View File

@@ -1,20 +1,41 @@
/*******************************************************************************
* 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.module.decode.p25; package io.github.dsheirer.module.decode.p25;
import io.github.dsheirer.alias.AliasList; import io.github.dsheirer.alias.AliasList;
import io.github.dsheirer.instrument.Instrumentable;
import io.github.dsheirer.module.decode.Decoder; import io.github.dsheirer.module.decode.Decoder;
import io.github.dsheirer.module.decode.DecoderType; import io.github.dsheirer.module.decode.DecoderType;
import io.github.dsheirer.source.tuner.frequency.IFrequencyChangeListener; import io.github.dsheirer.source.tuner.frequency.IFrequencyChangeListener;
import io.github.dsheirer.source.tuner.frequency.IFrequencyChangeProvider; import io.github.dsheirer.source.tuner.frequency.IFrequencyChangeProvider;
public abstract class P25Decoder extends Decoder implements IFrequencyChangeListener, IFrequencyChangeProvider, Instrumentable public abstract class P25Decoder extends Decoder implements IFrequencyChangeListener, IFrequencyChangeProvider
{ {
private P25MessageProcessor mMessageProcessor; private P25MessageProcessor mMessageProcessor;
private AliasList mAliasList;
public P25Decoder( AliasList aliasList ) public P25Decoder(AliasList aliasList)
{ {
mMessageProcessor = new P25MessageProcessor( aliasList ); mAliasList = aliasList;
mMessageProcessor.setMessageListener( this ); mMessageProcessor = new P25MessageProcessor(mAliasList);
mMessageProcessor.setMessageListener(getMessageListener());
}
protected AliasList getAliasList()
{
return mAliasList;
} }
public void dispose() public void dispose()
@@ -40,13 +61,13 @@ public abstract class P25Decoder extends Decoder implements IFrequencyChangeList
public enum Modulation public enum Modulation
{ {
CQPSK( "Simulcast (LSM)", "LSM" ), CQPSK("Simulcast (LSM)", "LSM"),
C4FM( "Normal (C4FM)", "C4FM" ); C4FM("Normal (C4FM)", "C4FM");
private String mLabel; private String mLabel;
private String mShortLabel; private String mShortLabel;
private Modulation( String label, String shortLabel ) private Modulation(String label, String shortLabel)
{ {
mLabel = label; mLabel = label;
mShortLabel = shortLabel; mShortLabel = shortLabel;

View File

@@ -7,7 +7,7 @@ import io.github.dsheirer.bits.ISyncDetectListener;
import io.github.dsheirer.bits.MultiSyncPatternMatcher; import io.github.dsheirer.bits.MultiSyncPatternMatcher;
import io.github.dsheirer.bits.SoftSyncDetector; import io.github.dsheirer.bits.SoftSyncDetector;
import io.github.dsheirer.bits.SyncDetector; import io.github.dsheirer.bits.SyncDetector;
import io.github.dsheirer.dsp.psk.LSMDemodulator; import io.github.dsheirer.dsp.psk.pll.IPhaseLockedLoop;
import io.github.dsheirer.dsp.symbol.Dibit; import io.github.dsheirer.dsp.symbol.Dibit;
import io.github.dsheirer.dsp.symbol.FrameSync; import io.github.dsheirer.dsp.symbol.FrameSync;
import io.github.dsheirer.edac.BCH_63_16_11; import io.github.dsheirer.edac.BCH_63_16_11;
@@ -40,7 +40,7 @@ import java.util.ArrayList;
public class P25MessageFramer implements Listener<Dibit> public class P25MessageFramer implements Listener<Dibit>
{ {
private final static Logger mLog = private final static Logger mLog =
LoggerFactory.getLogger( P25MessageFramer.class ); LoggerFactory.getLogger(P25MessageFramer.class);
/* Determines the threshold for sync pattern soft matching */ /* Determines the threshold for sync pattern soft matching */
private static final int SYNC_MATCH_THRESHOLD = 2; private static final int SYNC_MATCH_THRESHOLD = 2;
@@ -69,9 +69,9 @@ public class P25MessageFramer implements Listener<Dibit>
public static final int PDU3_DECODED_END = 448; public static final int PDU3_DECODED_END = 448;
private SoftSyncDetector mPrimarySyncDetector = new SoftSyncDetector( private SoftSyncDetector mPrimarySyncDetector = new SoftSyncDetector(
FrameSync.P25_PHASE1_NORMAL.getSync(), SYNC_MATCH_THRESHOLD ); FrameSync.P25_PHASE1_NORMAL.getSync(), SYNC_MATCH_THRESHOLD);
private MultiSyncPatternMatcher mMatcher = new MultiSyncPatternMatcher( 48 ); private MultiSyncPatternMatcher mMatcher = new MultiSyncPatternMatcher(48);
private ArrayList<P25MessageAssembler> mAssemblers = private ArrayList<P25MessageAssembler> mAssemblers =
new ArrayList<P25MessageAssembler>(); new ArrayList<P25MessageAssembler>();
@@ -88,27 +88,27 @@ public class P25MessageFramer implements Listener<Dibit>
* to the message length, and then broadcast that bit buffer to the registered * to the message length, and then broadcast that bit buffer to the registered
* listener. * listener.
*/ */
public P25MessageFramer( AliasList aliasList ) public P25MessageFramer(AliasList aliasList)
{ {
mAliasList = aliasList; mAliasList = aliasList;
mPrimarySyncDetector.setListener( new ISyncDetectListener() mPrimarySyncDetector.setListener(new ISyncDetectListener()
{ {
@Override @Override
public void syncDetected() public void syncDetected()
{ {
for( P25MessageAssembler assembler: mAssemblers ) for(P25MessageAssembler assembler : mAssemblers)
{ {
if( !assembler.isActive() ) if(!assembler.isActive())
{ {
assembler.setActive( true ); assembler.setActive(true);
break; break;
} }
} }
} }
} ); });
mMatcher.add( mPrimarySyncDetector ); mMatcher.add(mPrimarySyncDetector);
/** /**
* We use two message assemblers to catch any sync detections, so that * We use two message assemblers to catch any sync detections, so that
@@ -118,32 +118,32 @@ public class P25MessageFramer implements Listener<Dibit>
* sync pattern will produce a debug message indicating no assemblers * sync pattern will produce a debug message indicating no assemblers
* are available.. * are available..
*/ */
mAssemblers.add( new P25MessageAssembler() ); mAssemblers.add(new P25MessageAssembler());
mAssemblers.add( new P25MessageAssembler() ); mAssemblers.add(new P25MessageAssembler());
} }
public P25MessageFramer( AliasList aliasList, LSMDemodulator demodulator ) public P25MessageFramer(AliasList aliasList, IPhaseLockedLoop phaseLockedLoop)
{ {
this( aliasList ); this(aliasList);
if( demodulator != null ) if(phaseLockedLoop != null)
{ {
/* For CQPSK, we include 3 additional sync detectors to watch for and //Add additional sync pattern detectors to detect when we get 90/180 degree out of phase sync pattern
* correct +/-90 and 180 degree costas loop phase lock errors */ //detections so that we can apply correction to the phase locked loop
mMatcher.add( new CostasPhaseErrorDetector( FrameSync.P25_PHASE1_ERROR_90_CCW, mMatcher.add(new PLLPhaseInversionDetector(FrameSync.P25_PHASE1_ERROR_90_CCW,
demodulator, PHASE_CORRECTION_90_DEGREES ) ); phaseLockedLoop, PHASE_CORRECTION_90_DEGREES));
mMatcher.add( new CostasPhaseErrorDetector( FrameSync.P25_PHASE1_ERROR_90_CW, mMatcher.add(new PLLPhaseInversionDetector(FrameSync.P25_PHASE1_ERROR_90_CW,
demodulator, -PHASE_CORRECTION_90_DEGREES ) ); phaseLockedLoop, -PHASE_CORRECTION_90_DEGREES));
mMatcher.add( new CostasPhaseErrorDetector( FrameSync.P25_PHASE1_ERROR_180, mMatcher.add(new PLLPhaseInversionDetector(FrameSync.P25_PHASE1_ERROR_180,
demodulator, PHASE_CORRECTION_180_DEGREES ) ); phaseLockedLoop, PHASE_CORRECTION_180_DEGREES));
} }
} }
public void dispose() public void dispose()
{ {
for( P25MessageAssembler a: mAssemblers ) for(P25MessageAssembler a : mAssemblers)
{ {
a.dispose(); a.dispose();
} }
@@ -161,39 +161,39 @@ public class P25MessageFramer implements Listener<Dibit>
} }
private void dispatch( Message message ) private void dispatch(Message message)
{ {
if( mListener != null ) if(mListener != null)
{ {
mListener.receive( message ); mListener.receive(message);
} }
} }
@Override @Override
public void receive( Dibit symbol ) public void receive(Dibit symbol)
{ {
for( P25MessageAssembler assembler: mAssemblers ) for(P25MessageAssembler assembler : mAssemblers)
{ {
if( assembler.isActive() ) if(assembler.isActive())
{ {
assembler.receive( symbol ); assembler.receive(symbol);
if( assembler.complete() ) if(assembler.complete())
{ {
assembler.reset(); assembler.reset();
} }
} }
} }
mMatcher.receive( symbol.getBit1(), symbol.getBit2() ); mMatcher.receive(symbol.getBit1(), symbol.getBit2());
} }
public void setListener( Listener<Message> listener ) public void setListener(Listener<Message> listener)
{ {
mListener = listener; mListener = listener;
} }
public void removeListener( Listener<Message> listener ) public void removeListener(Listener<Message> listener)
{ {
mListener = null; mListener = null;
} }
@@ -212,15 +212,15 @@ public class P25MessageFramer implements Listener<Dibit>
public P25MessageAssembler() public P25MessageAssembler()
{ {
mMessageLength = mDUID.getMessageLength(); mMessageLength = mDUID.getMessageLength();
mMessage = new BinaryMessage( mMessageLength ); mMessage = new BinaryMessage(mMessageLength);
reset(); reset();
} }
public void receive( Dibit dibit ) public void receive(Dibit dibit)
{ {
if( mActive ) if(mActive)
{ {
if( mStatusSymbolPointer == 35 ) if(mStatusSymbolPointer == 35)
{ {
mStatusSymbolPointer = 0; mStatusSymbolPointer = 0;
} }
@@ -230,16 +230,16 @@ public class P25MessageFramer implements Listener<Dibit>
try try
{ {
mMessage.add( dibit.getBit1() ); mMessage.add(dibit.getBit1());
mMessage.add( dibit.getBit2() ); mMessage.add(dibit.getBit2());
} }
catch( BitSetFullException e ) catch(BitSetFullException e)
{ {
mComplete = true; mComplete = true;
} }
/* Check the message for complete */ /* Check the message for complete */
if( mMessage.isFull() ) if(mMessage.isFull())
{ {
checkComplete(); checkComplete();
} }
@@ -250,46 +250,46 @@ public class P25MessageFramer implements Listener<Dibit>
public void reset() public void reset()
{ {
mDUID = DataUnitID.NID; mDUID = DataUnitID.NID;
mMessage.setSize( mDUID.getMessageLength() ); mMessage.setSize(mDUID.getMessageLength());
mMessage.clear(); mMessage.clear();
mStatusSymbolPointer = 24; mStatusSymbolPointer = 24;
mComplete = false; mComplete = false;
mActive = false; mActive = false;
} }
public void setActive( boolean active ) public void setActive(boolean active)
{ {
mActive = active; mActive = active;
} }
private void setDUID( DataUnitID id ) private void setDUID(DataUnitID id)
{ {
mDUID = id; mDUID = id;
mMessageLength = id.getMessageLength(); mMessageLength = id.getMessageLength();
mMessage.setSize( mMessageLength ); mMessage.setSize(mMessageLength);
} }
private void checkComplete() private void checkComplete()
{ {
switch( mDUID ) switch(mDUID)
{ {
case NID: case NID:
mMessage = mNIDDecoder.correctNID( mMessage ); mMessage = mNIDDecoder.correctNID(mMessage);
if( mMessage.getCRC() != CRC.FAILED_CRC ) if(mMessage.getCRC() != CRC.FAILED_CRC)
{ {
int value = mMessage.getInt( P25Message.DUID ); int value = mMessage.getInt(P25Message.DUID);
DataUnitID duid = DataUnitID.fromValue( value ); DataUnitID duid = DataUnitID.fromValue(value);
if( duid != DataUnitID.UNKN ) if(duid != DataUnitID.UNKN)
{ {
setDUID( duid ); setDUID(duid);
} }
else else
{ {
mComplete = true; mComplete = true;
dispatch( new P25Message( mMessage.copy(), mDUID, mAliasList ) ); dispatch(new P25Message(mMessage.copy(), mDUID, mAliasList));
} }
} }
else else
@@ -299,58 +299,58 @@ public class P25MessageFramer implements Listener<Dibit>
break; break;
case HDU: case HDU:
mComplete = true; mComplete = true;
dispatch( new HDUMessage( mMessage.copy(), mDUID, mAliasList ) ); dispatch(new HDUMessage(mMessage.copy(), mDUID, mAliasList));
/* We're in a call now, lower the sync match threshold */ /* We're in a call now, lower the sync match threshold */
mPrimarySyncDetector.setThreshold( SYNC_IN_CALL_THRESHOLD ); mPrimarySyncDetector.setThreshold(SYNC_IN_CALL_THRESHOLD);
break; break;
case LDU1: case LDU1:
mComplete = true; mComplete = true;
LDU1Message ldu1 = new LDU1Message( mMessage.copy(), LDU1Message ldu1 = new LDU1Message(mMessage.copy(),
mDUID, mAliasList ); mDUID, mAliasList);
/* Convert the LDU1 message into a link control LDU1 message */ /* Convert the LDU1 message into a link control LDU1 message */
dispatch( LDULCMessageFactory.getMessage( ldu1 ) ); dispatch(LDULCMessageFactory.getMessage(ldu1));
/* We're in a call now, lower the sync match threshold */ /* We're in a call now, lower the sync match threshold */
mPrimarySyncDetector.setThreshold( SYNC_IN_CALL_THRESHOLD ); mPrimarySyncDetector.setThreshold(SYNC_IN_CALL_THRESHOLD);
break; break;
case LDU2: case LDU2:
mComplete = true; mComplete = true;
dispatch( new LDU2Message( mMessage.copy(), mDUID, mAliasList ) ); dispatch(new LDU2Message(mMessage.copy(), mDUID, mAliasList));
/* We're in a call now, lower the sync match threshold */ /* We're in a call now, lower the sync match threshold */
mPrimarySyncDetector.setThreshold( SYNC_IN_CALL_THRESHOLD ); mPrimarySyncDetector.setThreshold(SYNC_IN_CALL_THRESHOLD);
break; break;
case PDU0: case PDU0:
/* Remove interleaving */ /* Remove interleaving */
P25Interleave.deinterleaveData( mMessage, PDU0_BEGIN, PDU0_END ); P25Interleave.deinterleaveData(mMessage, PDU0_BEGIN, PDU0_END);
/* Remove trellis encoding - abort processing if we have an /* Remove trellis encoding - abort processing if we have an
* unsuccessful decode due to excessive errors */ * unsuccessful decode due to excessive errors */
if( mHalfRate.decode( mMessage, PDU0_BEGIN, PDU0_END ) ) if(mHalfRate.decode(mMessage, PDU0_BEGIN, PDU0_END))
{ {
mMessage = CRCP25.correctCCITT80( mMessage, mMessage = CRCP25.correctCCITT80(mMessage,
PDU0_BEGIN, PDU0_CRC_BEGIN ); PDU0_BEGIN, PDU0_CRC_BEGIN);
if( mMessage.getCRC() != CRC.FAILED_CRC ) if(mMessage.getCRC() != CRC.FAILED_CRC)
{ {
boolean confirmed = mMessage.get( boolean confirmed = mMessage.get(
PDUMessage.CONFIRMATION_REQUIRED_INDICATOR ); PDUMessage.CONFIRMATION_REQUIRED_INDICATOR);
if( confirmed ) if(confirmed)
{ {
setDUID( DataUnitID.PDUC ); setDUID(DataUnitID.PDUC);
} }
else else
{ {
setDUID( DataUnitID.PDU1 ); setDUID(DataUnitID.PDU1);
} }
mMessage.setPointer( PDU1_BEGIN ); mMessage.setPointer(PDU1_BEGIN);
} }
else else
{ {
@@ -363,33 +363,33 @@ public class P25MessageFramer implements Listener<Dibit>
} }
/* Set sync match threshold to normal */ /* Set sync match threshold to normal */
mPrimarySyncDetector.setThreshold( SYNC_MATCH_THRESHOLD ); mPrimarySyncDetector.setThreshold(SYNC_MATCH_THRESHOLD);
break; break;
case PDU1: case PDU1:
/* Remove interleaving */ /* Remove interleaving */
P25Interleave.deinterleaveData( mMessage, PDU1_BEGIN, PDU1_END ); P25Interleave.deinterleaveData(mMessage, PDU1_BEGIN, PDU1_END);
/* Remove trellis encoding - abort processing if we have an /* Remove trellis encoding - abort processing if we have an
* unsuccessful decode due to excessive errors */ * unsuccessful decode due to excessive errors */
if( mHalfRate.decode( mMessage, PDU1_BEGIN, PDU1_END ) ) if(mHalfRate.decode(mMessage, PDU1_BEGIN, PDU1_END))
{ {
if( mMessage.getInt( PDUMessage.BLOCKS_TO_FOLLOW ) == 1 ) if(mMessage.getInt(PDUMessage.BLOCKS_TO_FOLLOW) == 1)
{ {
mMessage.setSize( PDU2_BEGIN ); mMessage.setSize(PDU2_BEGIN);
PDUMessage pduMessage1 = PDUMessageFactory.getMessage( PDUMessage pduMessage1 = PDUMessageFactory.getMessage(
mMessage.copy(), DataUnitID.PDU1, mAliasList ); mMessage.copy(), DataUnitID.PDU1, mAliasList);
dispatch( pduMessage1 ); dispatch(pduMessage1);
mComplete = true; mComplete = true;
} }
else else
{ {
setDUID( DataUnitID.PDU2 ); setDUID(DataUnitID.PDU2);
mMessage.setPointer( PDU2_BEGIN ); mMessage.setPointer(PDU2_BEGIN);
} }
} }
else else
@@ -399,28 +399,28 @@ public class P25MessageFramer implements Listener<Dibit>
break; break;
case PDU2: case PDU2:
/* Remove interleaving */ /* Remove interleaving */
P25Interleave.deinterleaveData( mMessage, PDU2_BEGIN, PDU2_END ); P25Interleave.deinterleaveData(mMessage, PDU2_BEGIN, PDU2_END);
/* Remove trellis encoding - abort processing if we have an /* Remove trellis encoding - abort processing if we have an
* unsuccessful decode due to excessive errors */ * unsuccessful decode due to excessive errors */
if( mHalfRate.decode( mMessage, PDU2_BEGIN, PDU2_END ) ) if(mHalfRate.decode(mMessage, PDU2_BEGIN, PDU2_END))
{ {
if( mMessage.getInt( PDUMessage.BLOCKS_TO_FOLLOW ) == 2 ) if(mMessage.getInt(PDUMessage.BLOCKS_TO_FOLLOW) == 2)
{ {
mMessage.setSize( PDU3_BEGIN ); mMessage.setSize(PDU3_BEGIN);
PDUMessage pduMessage2 = PDUMessageFactory.getMessage( PDUMessage pduMessage2 = PDUMessageFactory.getMessage(
mMessage.copy(), DataUnitID.PDU2, mAliasList ); mMessage.copy(), DataUnitID.PDU2, mAliasList);
dispatch( pduMessage2 ); dispatch(pduMessage2);
mComplete = true; mComplete = true;
} }
else else
{ {
setDUID( DataUnitID.PDU3 ); setDUID(DataUnitID.PDU3);
mMessage.setPointer( PDU3_BEGIN ); mMessage.setPointer(PDU3_BEGIN);
} }
} }
else else
@@ -429,56 +429,56 @@ public class P25MessageFramer implements Listener<Dibit>
} }
/* Set sync match threshold to normal */ /* Set sync match threshold to normal */
mPrimarySyncDetector.setThreshold( SYNC_MATCH_THRESHOLD ); mPrimarySyncDetector.setThreshold(SYNC_MATCH_THRESHOLD);
break; break;
case PDU3: case PDU3:
/* Remove interleaving */ /* Remove interleaving */
P25Interleave.deinterleaveData( mMessage, PDU3_BEGIN, PDU3_END ); P25Interleave.deinterleaveData(mMessage, PDU3_BEGIN, PDU3_END);
/* Remove trellis encoding - abort processing if we have an /* Remove trellis encoding - abort processing if we have an
* unsuccessful decode due to excessive errors */ * unsuccessful decode due to excessive errors */
if( mHalfRate.decode( mMessage, PDU3_BEGIN, PDU3_END ) ) if(mHalfRate.decode(mMessage, PDU3_BEGIN, PDU3_END))
{ {
mMessage.setSize( PDU3_DECODED_END ); mMessage.setSize(PDU3_DECODED_END);
PDUMessage pduMessage3 = PDUMessageFactory.getMessage(mMessage.copy(), DataUnitID.PDU3, mAliasList ); PDUMessage pduMessage3 = PDUMessageFactory.getMessage(mMessage.copy(), DataUnitID.PDU3, mAliasList);
dispatch( pduMessage3 ); dispatch(pduMessage3);
} }
mComplete = true; mComplete = true;
break; break;
case PDUC: case PDUC:
/* De-interleave the latest block*/ /* De-interleave the latest block*/
P25Interleave.deinterleaveData( mMessage, P25Interleave.deinterleaveData(mMessage,
mMessage.size() - 196, mMessage.size() ); mMessage.size() - 196, mMessage.size());
/* Decode 3/4 rate convolutional encoding from latest block */ /* Decode 3/4 rate convolutional encoding from latest block */
if( mThreeQuarterRate.decode( mMessage, if(mThreeQuarterRate.decode(mMessage,
mMessage.size() - 196, mMessage.size() ) ) mMessage.size() - 196, mMessage.size()))
{ {
/* Resize the message and adjust the message pointer /* Resize the message and adjust the message pointer
* to account for removing 48 + 4 parity bits */ * to account for removing 48 + 4 parity bits */
mMessage.setSize( mMessage.size() - 52 ); mMessage.setSize(mMessage.size() - 52);
mMessage.adjustPointer( -52 ); mMessage.adjustPointer(-52);
int blocks = mMessage.getInt( PDUMessage.BLOCKS_TO_FOLLOW ); int blocks = mMessage.getInt(PDUMessage.BLOCKS_TO_FOLLOW);
int current = ( mMessage.size() - 160 ) / 144; int current = (mMessage.size() - 160) / 144;
if( current < blocks ) if(current < blocks)
{ {
mMessage.setSize( mMessage.size() + 196 ); mMessage.setSize(mMessage.size() + 196);
mMessageLength = mMessage.size(); mMessageLength = mMessage.size();
} }
else else
{ {
PDUConfirmedMessage pducm = PDUConfirmedMessage pducm =
new PDUConfirmedMessage( mMessage.copy(), new PDUConfirmedMessage(mMessage.copy(),
mAliasList ); mAliasList);
/* Translate into correct subclass */ /* Translate into correct subclass */
dispatch( PDUConfirmedMessageFactory.getMessage( pducm ) ); dispatch(PDUConfirmedMessageFactory.getMessage(pducm));
mComplete = true; mComplete = true;
} }
@@ -487,69 +487,69 @@ public class P25MessageFramer implements Listener<Dibit>
else else
{ {
PDUConfirmedMessage pducm = PDUConfirmedMessage pducm =
new PDUConfirmedMessage( mMessage.copy(), new PDUConfirmedMessage(mMessage.copy(),
mAliasList ); mAliasList);
/* Translate into correct subclass */ /* Translate into correct subclass */
dispatch( PDUConfirmedMessageFactory.getMessage( pducm ) ); dispatch(PDUConfirmedMessageFactory.getMessage(pducm));
mComplete = true; mComplete = true;
} }
/* Set sync match threshold to normal */ /* Set sync match threshold to normal */
mPrimarySyncDetector.setThreshold( SYNC_MATCH_THRESHOLD ); mPrimarySyncDetector.setThreshold(SYNC_MATCH_THRESHOLD);
break; break;
case TDU: case TDU:
dispatch( new TDUMessage( mMessage.copy(), mDUID, mAliasList ) ); dispatch(new TDUMessage(mMessage.copy(), mDUID, mAliasList));
mComplete = true; mComplete = true;
/* Set sync match threshold to normal */ /* Set sync match threshold to normal */
mPrimarySyncDetector.setThreshold( SYNC_MATCH_THRESHOLD ); mPrimarySyncDetector.setThreshold(SYNC_MATCH_THRESHOLD);
break; break;
case TDULC: case TDULC:
TDULinkControlMessage tdulc = new TDULinkControlMessage( TDULinkControlMessage tdulc = new TDULinkControlMessage(
mMessage.copy(), mDUID, mAliasList ); mMessage.copy(), mDUID, mAliasList);
/* Convert to an appropriate link control message */ /* Convert to an appropriate link control message */
tdulc = TDULCMessageFactory.getMessage( tdulc ); tdulc = TDULCMessageFactory.getMessage(tdulc);
dispatch( tdulc ); dispatch(tdulc);
mComplete = true; mComplete = true;
/* Set sync match threshold to normal */ /* Set sync match threshold to normal */
mPrimarySyncDetector.setThreshold( SYNC_MATCH_THRESHOLD ); mPrimarySyncDetector.setThreshold(SYNC_MATCH_THRESHOLD);
break; break;
case TSBK1: case TSBK1:
/* Remove interleaving */ /* Remove interleaving */
P25Interleave.deinterleaveData( mMessage, TSBK_BEGIN, TSBK_END ); P25Interleave.deinterleaveData(mMessage, TSBK_BEGIN, TSBK_END);
/* Remove trellis encoding - abort processing if we have an /* Remove trellis encoding - abort processing if we have an
* unsuccessful decode due to excessive errors */ * unsuccessful decode due to excessive errors */
if( mHalfRate.decode( mMessage, TSBK_BEGIN, TSBK_END ) ) if(mHalfRate.decode(mMessage, TSBK_BEGIN, TSBK_END))
{ {
mMessage = CRCP25.correctCCITT80( mMessage, mMessage = CRCP25.correctCCITT80(mMessage,
TSBK_BEGIN, TSBK_CRC_START ); TSBK_BEGIN, TSBK_CRC_START);
if( mMessage.getCRC() != CRC.FAILED_CRC ) if(mMessage.getCRC() != CRC.FAILED_CRC)
{ {
BinaryMessage tsbkBuffer1 = mMessage.copy(); BinaryMessage tsbkBuffer1 = mMessage.copy();
tsbkBuffer1.setSize( TSBK_DECODED_END ); tsbkBuffer1.setSize(TSBK_DECODED_END);
TSBKMessage tsbkMessage1 = TSBKMessageFactory.getMessage( TSBKMessage tsbkMessage1 = TSBKMessageFactory.getMessage(
tsbkBuffer1, DataUnitID.TSBK1, mAliasList ); tsbkBuffer1, DataUnitID.TSBK1, mAliasList);
if( tsbkMessage1.isLastBlock() ) if(tsbkMessage1.isLastBlock())
{ {
mComplete = true; mComplete = true;
} }
else else
{ {
setDUID( DataUnitID.TSBK2 ); setDUID(DataUnitID.TSBK2);
mMessage.setPointer( TSBK_BEGIN ); mMessage.setPointer(TSBK_BEGIN);
} }
dispatch( tsbkMessage1 ); dispatch(tsbkMessage1);
} }
else else
{ {
@@ -562,38 +562,38 @@ public class P25MessageFramer implements Listener<Dibit>
} }
/* Set sync match threshold to normal */ /* Set sync match threshold to normal */
mPrimarySyncDetector.setThreshold( SYNC_MATCH_THRESHOLD ); mPrimarySyncDetector.setThreshold(SYNC_MATCH_THRESHOLD);
break; break;
case TSBK2: case TSBK2:
/* Remove interleaving */ /* Remove interleaving */
P25Interleave.deinterleaveData( mMessage, TSBK_BEGIN, TSBK_END ); P25Interleave.deinterleaveData(mMessage, TSBK_BEGIN, TSBK_END);
/* Remove trellis encoding - abort processing if we have an /* Remove trellis encoding - abort processing if we have an
* unsuccessful decode due to excessive errors */ * unsuccessful decode due to excessive errors */
if( mHalfRate.decode( mMessage, TSBK_BEGIN, TSBK_END ) ) if(mHalfRate.decode(mMessage, TSBK_BEGIN, TSBK_END))
{ {
mMessage = CRCP25.correctCCITT80( mMessage, mMessage = CRCP25.correctCCITT80(mMessage,
TSBK_BEGIN, TSBK_CRC_START ); TSBK_BEGIN, TSBK_CRC_START);
if( mMessage.getCRC() != CRC.FAILED_CRC ) if(mMessage.getCRC() != CRC.FAILED_CRC)
{ {
BinaryMessage tsbkBuffer2 = mMessage.copy(); BinaryMessage tsbkBuffer2 = mMessage.copy();
tsbkBuffer2.setSize( TSBK_DECODED_END ); tsbkBuffer2.setSize(TSBK_DECODED_END);
TSBKMessage tsbkMessage2 = TSBKMessageFactory.getMessage( TSBKMessage tsbkMessage2 = TSBKMessageFactory.getMessage(
tsbkBuffer2, DataUnitID.TSBK2, mAliasList ); tsbkBuffer2, DataUnitID.TSBK2, mAliasList);
if( tsbkMessage2.isLastBlock() ) if(tsbkMessage2.isLastBlock())
{ {
mComplete = true; mComplete = true;
} }
else else
{ {
setDUID( DataUnitID.TSBK3 ); setDUID(DataUnitID.TSBK3);
mMessage.setPointer( TSBK_BEGIN ); mMessage.setPointer(TSBK_BEGIN);
} }
dispatch( tsbkMessage2 ); dispatch(tsbkMessage2);
} }
else else
{ {
@@ -607,24 +607,24 @@ public class P25MessageFramer implements Listener<Dibit>
break; break;
case TSBK3: case TSBK3:
/* Remove interleaving */ /* Remove interleaving */
P25Interleave.deinterleaveData( mMessage, TSBK_BEGIN, TSBK_END ); P25Interleave.deinterleaveData(mMessage, TSBK_BEGIN, TSBK_END);
/* Remove trellis encoding - abort processing if we have an /* Remove trellis encoding - abort processing if we have an
* unsuccessful decode due to excessive errors */ * unsuccessful decode due to excessive errors */
if( mHalfRate.decode( mMessage, TSBK_BEGIN, TSBK_END ) ) if(mHalfRate.decode(mMessage, TSBK_BEGIN, TSBK_END))
{ {
mMessage = CRCP25.correctCCITT80( mMessage, mMessage = CRCP25.correctCCITT80(mMessage,
TSBK_BEGIN, TSBK_CRC_START ); TSBK_BEGIN, TSBK_CRC_START);
if( mMessage.getCRC() != CRC.FAILED_CRC ) if(mMessage.getCRC() != CRC.FAILED_CRC)
{ {
BinaryMessage tsbkBuffer3 = mMessage.copy(); BinaryMessage tsbkBuffer3 = mMessage.copy();
tsbkBuffer3.setSize( TSBK_DECODED_END ); tsbkBuffer3.setSize(TSBK_DECODED_END);
TSBKMessage tsbkMessage3 = TSBKMessageFactory.getMessage( TSBKMessage tsbkMessage3 = TSBKMessageFactory.getMessage(
tsbkBuffer3, DataUnitID.TSBK3, mAliasList ); tsbkBuffer3, DataUnitID.TSBK3, mAliasList);
dispatch( tsbkMessage3 ); dispatch(tsbkMessage3);
} }
} }
@@ -632,15 +632,15 @@ public class P25MessageFramer implements Listener<Dibit>
break; break;
case VSELP1: case VSELP1:
mComplete = true; mComplete = true;
dispatch( new VSELP1Message( mMessage.copy(), mDUID, mAliasList ) ); dispatch(new VSELP1Message(mMessage.copy(), mDUID, mAliasList));
break; break;
case VSELP2: case VSELP2:
mComplete = true; mComplete = true;
dispatch( new VSELP2Message( mMessage.copy(), mDUID, mAliasList ) ); dispatch(new VSELP2Message(mMessage.copy(), mDUID, mAliasList));
break; break;
case UNKN: case UNKN:
mComplete = true; mComplete = true;
dispatch( new P25Message( mMessage.copy(), mDUID, mAliasList ) ); dispatch(new P25Message(mMessage.copy(), mDUID, mAliasList));
break; break;
default: default:
mComplete = true; mComplete = true;
@@ -681,37 +681,36 @@ public class P25MessageFramer implements Listener<Dibit>
* patterns and apply immediate phase correction so that message processing * patterns and apply immediate phase correction so that message processing
* can continue. * can continue.
*/ */
public class CostasPhaseErrorDetector extends SyncDetector public class PLLPhaseInversionDetector extends SyncDetector
{ {
private LSMDemodulator mDemodulator; private IPhaseLockedLoop mPhaseLockedLoop;
private double mCorrection; private double mCorrection;
public CostasPhaseErrorDetector( FrameSync frameSync, LSMDemodulator demodulator, double correction ) public PLLPhaseInversionDetector(FrameSync frameSync, IPhaseLockedLoop phaseLockedLoop, double correction)
{ {
super( frameSync.getSync() ); super(frameSync.getSync());
mDemodulator = demodulator;
mPhaseLockedLoop = phaseLockedLoop;
mCorrection = correction; mCorrection = correction;
setListener( new ISyncDetectListener() setListener(new ISyncDetectListener()
{ {
@Override @Override
public void syncDetected() public void syncDetected()
{ {
mDemodulator.correctPhaseError( mCorrection ); mPhaseLockedLoop.correctInversion(mCorrection);
/* Since we detected a sync pattern, start a message assembler */ /* Since we detected a sync pattern, start a message assembler */
for( P25MessageAssembler assembler: mAssemblers ) for(P25MessageAssembler assembler : mAssemblers)
{ {
if( !assembler.isActive() ) if(!assembler.isActive())
{ {
assembler.setActive( true ); assembler.setActive(true);
break; break;
} }
} }
} }
} ); });
} }
} }
} }

View File

@@ -19,10 +19,7 @@
package io.github.dsheirer.module.decode.p25; package io.github.dsheirer.module.decode.p25;
import io.github.dsheirer.alias.AliasList; import io.github.dsheirer.alias.AliasList;
import io.github.dsheirer.instrument.tap.Tap;
import io.github.dsheirer.instrument.tap.TapGroup; import io.github.dsheirer.instrument.tap.TapGroup;
import io.github.dsheirer.instrument.tap.stream.DibitTap;
import io.github.dsheirer.instrument.tap.stream.FloatTap;
import io.github.dsheirer.sample.Listener; import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.real.IFilteredRealBufferListener; import io.github.dsheirer.sample.real.IFilteredRealBufferListener;
import io.github.dsheirer.sample.real.RealBuffer; import io.github.dsheirer.sample.real.RealBuffer;
@@ -30,7 +27,6 @@ import io.github.dsheirer.source.tuner.frequency.FrequencyChangeEvent;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledExecutorService;
@@ -105,93 +101,6 @@ public class P25_C4FMDecoder extends P25Decoder implements IFilteredRealBufferLi
return mSymbolFilter; return mSymbolFilter;
} }
/**
* Instrumentation taps for monitoring internal processing
*/
@Override
public List<TapGroup> getTapGroups()
{
if( mAvailableTaps == null )
{
mAvailableTaps = new ArrayList<>();
TapGroup group = new TapGroup( "P25 C4FM Decoder" );
group.add( new FloatTap( INSTRUMENT_C4FM_SYMBOL_FILTER_OUTPUT, 0, 0.1f ) );
group.add( new DibitTap( INSTRUMENT_C4FM_SLICER_OUTPUT, 0, 0.1f ) );
mAvailableTaps.add( group );
if( mSymbolFilter != null )
{
mAvailableTaps.addAll( mSymbolFilter.getTapGroups() );
}
}
return mAvailableTaps;
}
/**
* Adds an instrumentation tap to monitor internal processing.
*/
@Override
public void registerTap( Tap tap )
{
if( mSymbolFilter != null )
{
mSymbolFilter.registerTap( tap );
}
switch( tap.getName() )
{
case INSTRUMENT_C4FM_SYMBOL_FILTER_OUTPUT:
FloatTap symbolTap = (FloatTap)tap;
mSymbolFilter.setListener( symbolTap );
symbolTap.setListener( mC4FMSlicer );
break;
case INSTRUMENT_C4FM_SLICER_OUTPUT:
DibitTap slicerTap = (DibitTap)tap;
if( mC4FMSlicer != null )
{
mC4FMSlicer.addListener( slicerTap );
}
break;
default:
break;
}
}
/**
* Removes the instrumentation tap.
*/
@Override
public void unregisterTap( Tap tap )
{
if( mSymbolFilter != null )
{
mSymbolFilter.unregisterTap( tap );
}
switch( tap.getName() )
{
case INSTRUMENT_C4FM_SYMBOL_FILTER_OUTPUT:
mSymbolFilter.setListener( mC4FMSlicer );
break;
case INSTRUMENT_C4FM_SLICER_OUTPUT:
DibitTap slicerTap = (DibitTap)tap;
if( mC4FMSlicer != null )
{
mC4FMSlicer.removeListener( slicerTap );
}
break;
default:
throw new IllegalArgumentException( "Unrecognized tap: " +
tap.getName() );
}
}
@Override @Override
public void reset() public void reset()
{ {

View File

@@ -0,0 +1,223 @@
/*******************************************************************************
* 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.module.decode.p25;
import io.github.dsheirer.alias.AliasList;
import io.github.dsheirer.dsp.filter.FilterFactory;
import io.github.dsheirer.dsp.filter.design.FilterDesignException;
import io.github.dsheirer.dsp.filter.fir.FIRFilterSpecification;
import io.github.dsheirer.dsp.filter.fir.complex.ComplexFIRFilter;
import io.github.dsheirer.dsp.gain.ComplexFeedForwardGainControl;
import io.github.dsheirer.dsp.psk.DQPSKSymbolPhaseErrorCalculator;
import io.github.dsheirer.dsp.psk.IQPSKSymbolDecoder;
import io.github.dsheirer.dsp.psk.ISymbolPhaseErrorCalculator;
import io.github.dsheirer.dsp.psk.QPSKDemodulator;
import io.github.dsheirer.dsp.psk.QPSKSymbolDecoder;
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.ComplexBuffer;
import io.github.dsheirer.sample.complex.ComplexBufferToStreamConverter;
import io.github.dsheirer.sample.complex.IComplexBufferListener;
import io.github.dsheirer.source.tuner.frequency.FrequencyChangeEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ScheduledExecutorService;
public class P25_C4FMDecoder2 extends P25Decoder implements IComplexBufferListener, Listener<ComplexBuffer>
{
private final static Logger mLog = LoggerFactory.getLogger(P25_C4FMDecoder2.class);
private static final double SYMBOL_RATE = 4800;
private double mSampleRate;
private Map<Double,float[]> mBasebandFilters = new HashMap<>();
private ComplexFIRFilter mBasebandFilter;
private QPSKDemodulator mQPSKDemodulator;
private IPhaseLockedLoop mPhaseLockedLoop;
private ComplexBufferToStreamConverter mStreamConverter = new ComplexBufferToStreamConverter();
private ComplexFeedForwardGainControl mAGC = new ComplexFeedForwardGainControl(32);
private QPSKSymbolDecoder mQPSKSlicer = new QPSKSymbolDecoder();
private P25MessageFramer mMessageFramer;
private ISymbolPhaseErrorCalculator mSymbolPhaseErrorCalculator = new DQPSKSymbolPhaseErrorCalculator();
private IQPSKSymbolDecoder mSymbolDecoder = new QPSKSymbolDecoder();
private Listener<Complex> mSymbolListener;
private Listener<Double> mPLLPhaseErrorListener;
public P25_C4FMDecoder2(AliasList aliasList)
{
super(aliasList);
setSampleRate(48000.0);
mStreamConverter.setListener(mAGC);
}
public void setSampleRate(double sampleRate)
{
if(sampleRate <= SYMBOL_RATE * 2)
{
throw new IllegalArgumentException("Sample rate must be at least twice the symbol rate [4800]");
}
mSampleRate = sampleRate;
mBasebandFilter = new ComplexFIRFilter(getBasebandFilter(), 1.0f);
mPhaseLockedLoop = new CostasLoop(mSampleRate, SYMBOL_RATE);
mQPSKDemodulator = new QPSKDemodulator(mPhaseLockedLoop, mSymbolPhaseErrorCalculator, mSymbolDecoder,
mSampleRate, SYMBOL_RATE);
mQPSKDemodulator.setSymbolListener(mSymbolListener);
mQPSKDemodulator.setPLLErrorListener(mPLLPhaseErrorListener);
//Message framer can trigger a symbol-inversion correction to the PLL when detected
mMessageFramer = new P25MessageFramer(getAliasList(), mPhaseLockedLoop);
mMessageFramer.setListener(getMessageProcessor());
mQPSKDemodulator.setDibitListener(mMessageFramer);
}
public void setSymbolListener(Listener<Complex> listener)
{
mSymbolListener = listener;
mQPSKDemodulator.setSymbolListener(listener);
}
public void setPLLPhaseErrorListener(Listener<Double> listener)
{
mPLLPhaseErrorListener = listener;
mQPSKDemodulator.setPLLErrorListener(listener);
}
@Override
public void receive(ComplexBuffer complexBuffer)
{
ComplexBuffer filtered = mBasebandFilter.filter(complexBuffer);
ComplexBuffer amplified = mAGC.filter(filtered);
mQPSKDemodulator.receive(amplified);
}
private double getSampleRate()
{
return mSampleRate;
}
private float[] getBasebandFilter()
{
float[] filter = mBasebandFilters.get(getSampleRate());
if(filter == null)
{
FIRFilterSpecification specification = FIRFilterSpecification.lowPassBuilder()
.sampleRate((int)getSampleRate())
.passBandCutoff(6000)
.passBandAmplitude(1.0)
.passBandRipple(0.1)
.stopBandAmplitude(0.0)
.stopBandStart(6250)
.stopBandRipple(0.01)
.build();
try
{
filter = FilterFactory.getTaps(specification);
mBasebandFilters.put(getSampleRate(), filter);
}
catch(FilterDesignException fde)
{
mLog.error("Couldn't design low pass baseband filter for sample rate: " + getSampleRate());
}
}
return filter;
}
public void dispose()
{
super.dispose();
mBasebandFilter.dispose();
mBasebandFilter = null;
mStreamConverter.dispose();
mStreamConverter = null;
mAGC.dispose();
mAGC = null;
mQPSKSlicer.dispose();
mQPSKSlicer = null;
mMessageFramer.dispose();
mMessageFramer = null;
}
@Override
public void setFrequencyChangeListener(Listener<FrequencyChangeEvent> listener)
{
}
@Override
public void removeFrequencyChangeListener()
{
}
@Override
public Listener<FrequencyChangeEvent> getFrequencyChangeListener()
{
return new Listener<FrequencyChangeEvent>()
{
@Override
public void receive(FrequencyChangeEvent frequencyChangeEvent)
{
//Ignored
}
};
}
@Override
public Listener<ComplexBuffer> getComplexBufferListener()
{
return P25_C4FMDecoder2.this;
}
public Modulation getModulation()
{
return Modulation.C4FM;
}
@Override
public void reset()
{
// TODO Auto-generated method stub
}
@Override
public void start(ScheduledExecutorService executor)
{
// TODO Auto-generated method stub
}
@Override
public void stop()
{
// TODO Auto-generated method stub
}
}

View File

@@ -23,13 +23,8 @@ import io.github.dsheirer.dsp.filter.Window.WindowType;
import io.github.dsheirer.dsp.filter.fir.complex.ComplexFIRFilter_CB_CB; import io.github.dsheirer.dsp.filter.fir.complex.ComplexFIRFilter_CB_CB;
import io.github.dsheirer.dsp.gain.ComplexFeedForwardGainControl; import io.github.dsheirer.dsp.gain.ComplexFeedForwardGainControl;
import io.github.dsheirer.dsp.psk.LSMDemodulator; import io.github.dsheirer.dsp.psk.LSMDemodulator;
import io.github.dsheirer.dsp.psk.QPSKPolarSlicer; import io.github.dsheirer.dsp.psk.QPSKSymbolDecoder;
import io.github.dsheirer.instrument.tap.Tap;
import io.github.dsheirer.instrument.tap.TapGroup; import io.github.dsheirer.instrument.tap.TapGroup;
import io.github.dsheirer.instrument.tap.stream.ComplexSampleTap;
import io.github.dsheirer.instrument.tap.stream.ComplexTap;
import io.github.dsheirer.instrument.tap.stream.DibitTap;
import io.github.dsheirer.instrument.tap.stream.QPSKTap;
import io.github.dsheirer.sample.Listener; import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.complex.ComplexBuffer; import io.github.dsheirer.sample.complex.ComplexBuffer;
import io.github.dsheirer.sample.complex.ComplexBufferToStreamConverter; import io.github.dsheirer.sample.complex.ComplexBufferToStreamConverter;
@@ -38,13 +33,12 @@ import io.github.dsheirer.source.tuner.frequency.FrequencyChangeEvent;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledExecutorService;
public class P25_LSMDecoder extends P25Decoder implements IComplexBufferListener public class P25_LSMDecoder extends P25Decoder implements IComplexBufferListener
{ {
private final static Logger mLog = LoggerFactory.getLogger( P25_LSMDecoder.class ); private final static Logger mLog = LoggerFactory.getLogger(P25_LSMDecoder.class);
/* Instrumentation Taps */ /* Instrumentation Taps */
private static final String INSTRUMENT_BASEBAND_FILTER_OUTPUT = "Tap Point: Baseband Filter Output"; private static final String INSTRUMENT_BASEBAND_FILTER_OUTPUT = "Tap Point: Baseband Filter Output";
@@ -57,30 +51,30 @@ public class P25_LSMDecoder extends P25Decoder implements IComplexBufferListener
private ComplexFIRFilter_CB_CB mBasebandFilter; private ComplexFIRFilter_CB_CB mBasebandFilter;
private ComplexBufferToStreamConverter mStreamConverter = new ComplexBufferToStreamConverter(); private ComplexBufferToStreamConverter mStreamConverter = new ComplexBufferToStreamConverter();
private ComplexFeedForwardGainControl mAGC = private ComplexFeedForwardGainControl mAGC =
new ComplexFeedForwardGainControl( 32 ); new ComplexFeedForwardGainControl(32);
private LSMDemodulator mLSMDemodulator = new LSMDemodulator(); private LSMDemodulator mLSMDemodulator = new LSMDemodulator();
private QPSKPolarSlicer mQPSKSlicer = new QPSKPolarSlicer(); private QPSKSymbolDecoder mQPSKSlicer = new QPSKSymbolDecoder();
private P25MessageFramer mMessageFramer; private P25MessageFramer mMessageFramer;
public P25_LSMDecoder( AliasList aliasList ) public P25_LSMDecoder(AliasList aliasList)
{ {
super( aliasList ); super(aliasList);
mBasebandFilter = new ComplexFIRFilter_CB_CB( FilterFactory.getLowPass( mBasebandFilter = new ComplexFIRFilter_CB_CB(FilterFactory.getLowPass(
48000, 7250, 8000, 60, WindowType.HANNING, true ), 1.0f ); 48000, 7250, 8000, 60, WindowType.HANNING, true), 1.0f);
mBasebandFilter.setListener( mStreamConverter ); mBasebandFilter.setListener(mStreamConverter);
mStreamConverter.setListener( mAGC ); mStreamConverter.setListener(mAGC);
mAGC.setListener( mLSMDemodulator ); mAGC.setListener(mLSMDemodulator);
mLSMDemodulator.setSymbolListener( mQPSKSlicer ); mLSMDemodulator.setSymbolListener(mQPSKSlicer);
mMessageFramer = new P25MessageFramer( aliasList, mLSMDemodulator ); mMessageFramer = new P25MessageFramer(aliasList, mLSMDemodulator.getCostasLoop());
mQPSKSlicer.addListener( mMessageFramer ); mQPSKSlicer.addListener(mMessageFramer);
mMessageFramer.setListener( getMessageProcessor() ); mMessageFramer.setListener(getMessageProcessor());
} }
public void dispose() public void dispose()
@@ -140,102 +134,6 @@ public class P25_LSMDecoder extends P25Decoder implements IComplexBufferListener
return Modulation.CQPSK; return Modulation.CQPSK;
} }
/**
* Provides a list of instrumentation taps for monitoring internal processing
*/
@Override
public List<TapGroup> getTapGroups()
{
if( mAvailableTaps == null )
{
mAvailableTaps = new ArrayList<>();
TapGroup group = new TapGroup( "P25 LSM Decoder" );
group.add( new ComplexTap( INSTRUMENT_BASEBAND_FILTER_OUTPUT, 0, 1.0f ) );
group.add( new ComplexTap( INSTRUMENT_AGC_OUTPUT, 0, 1.0f ) );
group.add( new QPSKTap( INSTRUMENT_LSM_DEMODULATOR_OUTPUT, 0, 1.0f ) );
group.add( new DibitTap( INSTRUMENT_QPSK_SLICER_OUTPUT, 0, 0.1f ) );
mAvailableTaps.add( group );
if( mLSMDemodulator != null )
{
mAvailableTaps.addAll( mLSMDemodulator.getTapGroups() );
}
}
return mAvailableTaps;
}
/**
* Adds the instrumentation tap
*/
@Override
public void registerTap( Tap tap )
{
if( mLSMDemodulator != null )
{
mLSMDemodulator.registerTap( tap );
}
switch( tap.getName() )
{
case INSTRUMENT_BASEBAND_FILTER_OUTPUT:
ComplexSampleTap baseband = (ComplexSampleTap)tap;
mStreamConverter.setListener( baseband );
baseband.setListener( mAGC );
break;
case INSTRUMENT_AGC_OUTPUT:
ComplexSampleTap agcSymbol = (ComplexSampleTap)tap;
mAGC.setListener( agcSymbol );
agcSymbol.setListener( mLSMDemodulator );
break;
case INSTRUMENT_LSM_DEMODULATOR_OUTPUT:
QPSKTap qpsk = (QPSKTap)tap;
mLSMDemodulator.setSymbolListener( qpsk );
qpsk.setListener( mQPSKSlicer );
break;
case INSTRUMENT_QPSK_SLICER_OUTPUT:
mQPSKSlicer.addListener( (DibitTap)tap );
break;
default:
throw new IllegalArgumentException( "Unrecognized tap: " +
tap.getName() );
}
}
/**
* Removes the instrumentation tap
*/
@Override
public void unregisterTap( Tap tap )
{
if( mLSMDemodulator != null )
{
mLSMDemodulator.unregisterTap( tap );
}
switch( tap.getName() )
{
case INSTRUMENT_BASEBAND_FILTER_OUTPUT:
mStreamConverter.setListener( mAGC );
break;
case INSTRUMENT_AGC_OUTPUT:
mAGC.setListener( mLSMDemodulator );
break;
case INSTRUMENT_LSM_DEMODULATOR_OUTPUT:
mLSMDemodulator.setSymbolListener( mQPSKSlicer );
break;
case INSTRUMENT_QPSK_SLICER_OUTPUT:
mQPSKSlicer.removeListener( (DibitTap)tap );
break;
default:
throw new IllegalArgumentException( "Unrecognized tap: " +
tap.getName() );
}
}
@Override @Override
public void reset() public void reset()
{ {
@@ -244,7 +142,7 @@ public class P25_LSMDecoder extends P25Decoder implements IComplexBufferListener
} }
@Override @Override
public void start( ScheduledExecutorService executor ) public void start(ScheduledExecutorService executor)
{ {
// TODO Auto-generated method stub // TODO Auto-generated method stub

View File

@@ -63,7 +63,7 @@ public class PassportDecoder extends Decoder
mPassportMessageProcessor = new PassportMessageProcessor( aliasList ); mPassportMessageProcessor = new PassportMessageProcessor( aliasList );
mPassportMessageFramer.addMessageListener( mPassportMessageProcessor ); mPassportMessageFramer.addMessageListener( mPassportMessageProcessor );
mPassportMessageProcessor.setMessageListener( this ); mPassportMessageProcessor.setMessageListener( getMessageListener() );
} }
@Override @Override

View File

@@ -104,8 +104,8 @@ public class Tait1200Decoder extends Decoder implements IFilteredRealBufferListe
mMessageFramerGPS.addMessageListener( mMessageAProcessor ); mMessageFramerGPS.addMessageListener( mMessageAProcessor );
mMessageFramerANI.addMessageListener( mMessageBProcessor ); mMessageFramerANI.addMessageListener( mMessageBProcessor );
mMessageAProcessor.setMessageListener( this ); mMessageAProcessor.setMessageListener(getMessageListener());
mMessageBProcessor.setMessageListener( this ); mMessageBProcessor.setMessageListener(getMessageListener());
} }
public void dispose() public void dispose()

View File

@@ -42,6 +42,7 @@ public class RecorderManager implements Listener<AudioPacket>
private static final Logger mLog = LoggerFactory.getLogger(RecorderManager.class); private static final Logger mLog = LoggerFactory.getLogger(RecorderManager.class);
public static final int AUDIO_SAMPLE_RATE = 8000; public static final int AUDIO_SAMPLE_RATE = 8000;
public static final int BASEBAND_SAMPLE_RATE = 48000;
public static final long IDLE_RECORDER_REMOVAL_THRESHOLD = 6000; //6 seconds public static final long IDLE_RECORDER_REMOVAL_THRESHOLD = 6000; //6 seconds
private Map<String,AudioPacketWaveRecorder> mRecorders = new HashMap<>(); private Map<String,AudioPacketWaveRecorder> mRecorders = new HashMap<>();
@@ -229,7 +230,7 @@ public class RecorderManager implements Listener<AudioPacket>
sb.append(SystemProperties.getInstance().getApplicationFolder("recordings")); sb.append(SystemProperties.getInstance().getApplicationFolder("recordings"));
sb.append(File.separator).append(channelName).append("_baseband"); sb.append(File.separator).append(channelName).append("_baseband");
return new ComplexBufferWaveRecorder(AUDIO_SAMPLE_RATE, sb.toString()); return new ComplexBufferWaveRecorder(BASEBAND_SAMPLE_RATE, sb.toString());
} }
/** /**

View File

@@ -27,15 +27,14 @@ import java.io.Serializable;
*/ */
public class Complex implements Serializable public class Complex implements Serializable
{ {
private final static Logger mLog = private final static Logger mLog = LoggerFactory.getLogger(Complex.class);
LoggerFactory.getLogger( Complex.class );
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
private float mLeft; private float mLeft;
private float mRight; private float mRight;
public Complex( float left, float right ) public Complex(float left, float right)
{ {
mLeft = left; mLeft = left;
mRight = right; mRight = right;
@@ -43,38 +42,44 @@ public class Complex implements Serializable
public Complex() public Complex()
{ {
this( 0.0f, 0.0f ); this(0.0f, 0.0f);
} }
public void setInphase( float inphase ) public void setInphase(float inphase)
{ {
mLeft = inphase; mLeft = inphase;
} }
public void setQuadrature( float quadrature ) public void setQuadrature(float quadrature)
{ {
mRight = quadrature; mRight = quadrature;
} }
public void setValues( float inphase, float quadrature ) public void setValues(float inphase, float quadrature)
{ {
mLeft = inphase; mLeft = inphase;
mRight = quadrature; mRight = quadrature;
} }
public void setValues(Complex sampleToCopy)
{
mLeft = sampleToCopy.left();
mRight = sampleToCopy.right();
}
public Complex copy() public Complex copy()
{ {
return new Complex( mLeft, mRight ); return new Complex(mLeft, mRight);
} }
public String toString() public String toString()
{ {
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
sb.append( "I:" ); sb.append("I:");
sb.append( mLeft ); sb.append(mLeft);
sb.append( " Q:" ); sb.append(" Q:");
sb.append( mRight ); sb.append(mRight);
return sb.toString(); return sb.toString();
} }
@@ -84,49 +89,49 @@ public class Complex implements Serializable
*/ */
public Complex conjugate() public Complex conjugate()
{ {
return new Complex( mLeft, -mRight ); return new Complex(mLeft, -mRight);
} }
/** /**
* Multiplies this sample by the scalor value * Multiplies this sample by the scalor value
*/ */
public void multiply( float scalor ) public void multiply(float scalor)
{ {
mLeft *= scalor; mLeft *= scalor;
mRight *= scalor; mRight *= scalor;
} }
public static Complex multiply( Complex sample, float scalor ) public static Complex multiply(Complex sample, float scalor)
{ {
return new Complex( sample.left() * scalor, return new Complex(sample.left() * scalor,
sample.right() * scalor ); sample.right() * scalor);
} }
/** /**
* Calculates the inphase component of multiplying two complex numbers, A and B. * Calculates the inphase component of multiplying two complex numbers, A and B.
*/ */
public static float multiplyInphase( float inphaseA, float quadratureA, float inphaseB, float quadratureB ) public static float multiplyInphase(float inphaseA, float quadratureA, float inphaseB, float quadratureB)
{ {
return ( inphaseA * inphaseB ) - ( quadratureA * quadratureB ); return (inphaseA * inphaseB) - (quadratureA * quadratureB);
} }
/** /**
* Calculates the quadrature component of multiplying two complex numbers, A and B. * Calculates the quadrature component of multiplying two complex numbers, A and B.
*/ */
public static float multiplyQuadrature( float inphaseA, float quadratureA, float inphaseB, float quadratureB ) public static float multiplyQuadrature(float inphaseA, float quadratureA, float inphaseB, float quadratureB)
{ {
return ( quadratureA * inphaseB ) + ( inphaseA * quadratureB ); return (quadratureA * inphaseB) + (inphaseA * quadratureB);
} }
/** /**
* Multiplies this sample by the multiplier sample * Multiplies this sample by the multiplier sample
*/ */
public void multiply( Complex multiplier ) public void multiply(Complex multiplier)
{ {
float inphase = multiplyInphase( inphase(), quadrature(), float inphase = multiplyInphase(inphase(), quadrature(),
multiplier.inphase(), multiplier.quadrature() ); multiplier.inphase(), multiplier.quadrature());
float quadrature = multiplyQuadrature( inphase(), quadrature(), float quadrature = multiplyQuadrature(inphase(), quadrature(),
multiplier.inphase(), multiplier.quadrature() ); multiplier.inphase(), multiplier.quadrature());
mLeft = inphase; mLeft = inphase;
mRight = quadrature; mRight = quadrature;
@@ -135,47 +140,47 @@ public class Complex implements Serializable
/** /**
* Multiplies both samples returning a new sample with the results * Multiplies both samples returning a new sample with the results
*/ */
public static Complex multiply( Complex sample1, Complex sample2 ) public static Complex multiply(Complex sample1, Complex sample2)
{ {
float inphase = multiplyInphase( sample1.inphase(), sample1.quadrature(), float inphase = multiplyInphase(sample1.inphase(), sample1.quadrature(),
sample2.inphase(), sample2.quadrature() ); sample2.inphase(), sample2.quadrature());
float quadrature = multiplyQuadrature( sample1.inphase(), sample1.quadrature(), float quadrature = multiplyQuadrature(sample1.inphase(), sample1.quadrature(),
sample2.inphase(), sample2.quadrature() ); sample2.inphase(), sample2.quadrature());
return new Complex( inphase, quadrature ); return new Complex(inphase, quadrature);
} }
public static Complex multiply( Complex sample, public static Complex multiply(Complex sample,
Float inphase, Float quadrature ) Float inphase, Float quadrature)
{ {
float i = multiplyInphase( sample.inphase(), sample.quadrature(), float i = multiplyInphase(sample.inphase(), sample.quadrature(),
inphase, quadrature ); inphase, quadrature);
float q = multiplyQuadrature( sample.inphase(), sample.quadrature(), float q = multiplyQuadrature(sample.inphase(), sample.quadrature(),
inphase, quadrature ); inphase, quadrature);
return new Complex( i, q ); return new Complex(i, q);
} }
public static Complex multiply( Float inphase, Float quadrature, Complex sample ) public static Complex multiply(Float inphase, Float quadrature, Complex sample)
{ {
float i = multiplyInphase( inphase, quadrature, sample.inphase(), sample.quadrature() ); float i = multiplyInphase(inphase, quadrature, sample.inphase(), sample.quadrature());
float q = multiplyQuadrature( inphase, quadrature, sample.inphase(), sample.quadrature() ); float q = multiplyQuadrature(inphase, quadrature, sample.inphase(), sample.quadrature());
return new Complex( i, q ); return new Complex(i, q);
} }
public static Complex multiply( float inphaseA, float quadratureA, float inphaseB, float quadratureB ) public static Complex multiply(float inphaseA, float quadratureA, float inphaseB, float quadratureB)
{ {
float i = multiplyInphase( inphaseA, quadratureA, inphaseB, quadratureB ); float i = multiplyInphase(inphaseA, quadratureA, inphaseB, quadratureB);
float q = multiplyQuadrature( inphaseA, quadratureA, inphaseB, quadratureB ); float q = multiplyQuadrature(inphaseA, quadratureA, inphaseB, quadratureB);
return new Complex( i, q ); return new Complex(i, q);
} }
/** /**
* Adds the adder sample value to this sample * Adds the adder sample value to this sample
*/ */
public void add( Complex adder ) public void add(Complex adder)
{ {
mLeft += adder.left(); mLeft += adder.left();
mRight += adder.right(); mRight += adder.right();
@@ -184,19 +189,19 @@ public class Complex implements Serializable
/** /**
* Adds the two complex samples returning a new complex sample with the result * Adds the two complex samples returning a new complex sample with the result
*/ */
public static Complex add( Complex first, Complex second ) public static Complex add(Complex first, Complex second)
{ {
return new Complex( first.left() + second.left(), return new Complex(first.left() + second.left(),
first.right() + second.right() ); first.right() + second.right());
} }
/** /**
* Adds the two complex samples returning a new complex sample with the result * Adds the two complex samples returning a new complex sample with the result
*/ */
public static Complex subtract( Complex first, Complex second ) public static Complex subtract(Complex first, Complex second)
{ {
return new Complex( first.left() - second.left(), return new Complex(first.left() - second.left(),
first.right() - second.right() ); first.right() - second.right());
} }
/** /**
@@ -204,12 +209,12 @@ public class Complex implements Serializable
*/ */
public float magnitude() public float magnitude()
{ {
return (float)Math.sqrt( magnitudeSquared() ); return (float)Math.sqrt(magnitudeSquared());
} }
public static float magnitude( float inphase, float quadrature ) public static float magnitude(float inphase, float quadrature)
{ {
return (float)Math.sqrt( ( inphase * inphase ) + ( quadrature * quadrature ) ); return (float)Math.sqrt((inphase * inphase) + (quadrature * quadrature));
} }
/** /**
@@ -225,8 +230,8 @@ public class Complex implements Serializable
*/ */
public float norm() public float norm()
{ {
return (float)( ( inphase() * inphase() ) + return (float)((inphase() * inphase()) +
( quadrature() * quadrature() ) ); (quadrature() * quadrature()));
} }
/** /**
@@ -236,9 +241,9 @@ public class Complex implements Serializable
{ {
float magnitude = magnitude(); float magnitude = magnitude();
if( magnitude != 0 ) if(magnitude != 0)
{ {
multiply( (float)( 1.0f / magnitude() ) ); multiply((float)(1.0f / magnitude()));
} }
} }
@@ -248,7 +253,7 @@ public class Complex implements Serializable
*/ */
public void fastNormalize() public void fastNormalize()
{ {
multiply( (float)( 1.95f - magnitudeSquared() ) ); multiply((float)(1.95f - magnitudeSquared()));
} }
public float left() public float left()
@@ -271,7 +276,7 @@ public class Complex implements Serializable
*/ */
public float inPhaseAbsolute() public float inPhaseAbsolute()
{ {
return Math.abs( mLeft ); return Math.abs(mLeft);
} }
public float quadrature() public float quadrature()
@@ -284,7 +289,7 @@ public class Complex implements Serializable
*/ */
public float quadratureAbsolute() public float quadratureAbsolute()
{ {
return Math.abs( mRight ); return Math.abs(mRight);
} }
public float x() public float x()
@@ -307,7 +312,7 @@ public class Complex implements Serializable
*/ */
public float realAbsolute() public float realAbsolute()
{ {
return Math.abs( mLeft ); return Math.abs(mLeft);
} }
public float imaginary() public float imaginary()
@@ -320,7 +325,7 @@ public class Complex implements Serializable
*/ */
public float imaginaryAbsolute() public float imaginaryAbsolute()
{ {
return Math.abs( mRight ); return Math.abs(mRight);
} }
/** /**
@@ -328,26 +333,36 @@ public class Complex implements Serializable
*/ */
public float maximumAbsolute() public float maximumAbsolute()
{ {
if( Math.abs( mLeft ) > Math.abs( mRight ) ) if(Math.abs(mLeft) > Math.abs(mRight))
{ {
return Math.abs( mLeft ); return Math.abs(mLeft);
} }
else else
{ {
return Math.abs( mRight ); return Math.abs(mRight);
} }
} }
/** /**
* Creates a new complex sample representing the angle with unit circle * Creates a new complex sample representing the angle with unit circle
* magnitude * magnitude
*
* @param angle in radians * @param angle in radians
* @return * @return
*/ */
public static Complex fromAngle( float angle ) public static Complex fromAngle(double angle)
{ {
return new Complex( (float)Math.cos( angle ), return new Complex((float)Math.cos(angle), (float)Math.sin(angle));
(float)Math.sin( angle ) ); }
/**
* Sets this complex instance with the specified angle in radians.
* @param angle in radians
*/
public void setAngle(double angle)
{
setInphase((float)Math.cos(angle));
setQuadrature((float)Math.sin(angle));
} }
/** /**
@@ -355,7 +370,7 @@ public class Complex implements Serializable
*/ */
public float angle() public float angle()
{ {
return (float)Math.atan2( y(), x() ); return (float)Math.atan2(y(), x());
} }
public float angleDegrees() public float angleDegrees()
@@ -368,22 +383,22 @@ public class Complex implements Serializable
* *
* @param value - maximum absolute value * @param value - maximum absolute value
*/ */
public void clip( float value ) public void clip(float value)
{ {
if( mLeft > value ) if(mLeft > value)
{ {
mLeft = value; mLeft = value;
} }
else if( mLeft < -value ) else if(mLeft < -value)
{ {
mLeft = -value; mLeft = -value;
} }
if( mRight > value ) if(mRight > value)
{ {
mRight = value; mRight = value;
} }
else if( mRight < -value ) else if(mRight < -value)
{ {
mRight = -value; mRight = -value;
} }
@@ -394,7 +409,7 @@ public class Complex implements Serializable
*/ */
public float polarAngle() public float polarAngle()
{ {
return (float)Math.toDegrees( angle() ); return (float)Math.toDegrees(angle());
} }
/** /**
@@ -402,37 +417,37 @@ public class Complex implements Serializable
*/ */
public float envelope() public float envelope()
{ {
return envelope( mLeft, mRight ); return envelope(mLeft, mRight);
} }
public static float envelope( float inphase, float quadrature ) public static float envelope(float inphase, float quadrature)
{ {
float inphaseAbsolute = Math.abs( inphase ); float inphaseAbsolute = Math.abs(inphase);
float quadratureAbsolute = Math.abs( quadrature ); float quadratureAbsolute = Math.abs(quadrature);
if( inphaseAbsolute > quadratureAbsolute ) if(inphaseAbsolute > quadratureAbsolute)
{ {
return inphaseAbsolute + ( 0.4f * quadratureAbsolute ); return inphaseAbsolute + (0.4f * quadratureAbsolute);
} }
else else
{ {
return quadratureAbsolute + ( 0.4f * inphaseAbsolute ); return quadratureAbsolute + (0.4f * inphaseAbsolute);
} }
} }
public static void main( String[] args ) public static void main(String[] args)
{ {
double angle = Math.PI; //180 degrees double angle = Math.PI; //180 degrees
Complex s1 = new Complex( (float)Math.sin( angle ), (float)Math.cos( angle ) ); Complex s1 = new Complex((float)Math.sin(angle), (float)Math.cos(angle));
Complex tap = new Complex( 1.0f, -0.1f ); Complex tap = new Complex(1.0f, -0.1f);
Complex convolved = Complex.multiply( s1, tap ); Complex convolved = Complex.multiply(s1, tap);
mLog.debug( "s: " + s1.toString() + mLog.debug("s: " + s1.toString() +
" t: " + tap.toString() + " t: " + tap.toString() +
" convolved: " + convolved.toString() ); " convolved: " + convolved.toString());
} }
} }

View File

@@ -1,3 +1,18 @@
/*******************************************************************************
* 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.source; package io.github.dsheirer.source;
import javax.sound.sampled.UnsupportedAudioFileException; import javax.sound.sampled.UnsupportedAudioFileException;
@@ -19,13 +34,15 @@ public interface IControllableFileSource
public File getFile(); public File getFile();
public void next( int frames ) throws IOException; public void next(int frames) throws IOException;
public void next( int frames, boolean broadcast ) throws IOException; public void next(int frames, boolean broadcast) throws IOException;
public long getFrameCount() throws IOException; public long getFrameCount() throws IOException;
public void setListener( IFrameLocationListener listener ); public int getSampleRate();
public void removeListener( IFrameLocationListener listener ); public void setListener(IFrameLocationListener listener);
public void removeListener(IFrameLocationListener listener);
} }