Merge pull request #338 from DSheirer/330-p25-c4fm-decoder-update

330 p25 c4fm decoder update
This commit is contained in:
Denny Sheirer
2018-03-17 13:51:19 +00:00
committed by GitHub
71 changed files with 6092 additions and 2628 deletions

View File

@@ -54,6 +54,8 @@ dependencies {
compile 'org.apache.axis:axis-jaxrpc:1.4' compile 'org.apache.axis:axis-jaxrpc:1.4'
compile 'org.apache.axis:axis:1.4' compile 'org.apache.axis:axis:1.4'
compile 'com.fasterxml.jackson.dataformat:jackson-dataformat-xml:2.9.3' compile 'com.fasterxml.jackson.dataformat:jackson-dataformat-xml:2.9.3'
compile 'org.kordamp.ikonli:ikonli-javafx:2.1.1'
compile 'org.kordamp.ikonli:ikonli-fontawesome-pack:2.1.1'
} }
task wrapper(type: Wrapper) { task wrapper(type: Wrapper) {

View File

@@ -1,6 +1,6 @@
/******************************************************************************* /*******************************************************************************
* SDR Trunk * SDR Trunk
* Copyright (C) 2014 Dennis Sheirer * Copyright (C) 2014-2018 Dennis Sheirer
* *
* This program is free software: you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
@@ -33,53 +33,62 @@ public class ComplexCircularBuffer
Complex[] mBuffer; Complex[] mBuffer;
int mBufferPointer = 0; int mBufferPointer = 0;
public ComplexCircularBuffer( int size ) public ComplexCircularBuffer(int size)
{ {
mBuffer = new Complex[ size ]; mBuffer = new Complex[size];
Arrays.fill( mBuffer, new Complex( 1.0f, 1.0f ) ); Arrays.fill(mBuffer, new Complex(1.0f, 1.0f));
}
public int length()
{
return mBuffer.length;
} }
/** /**
* Returns the sample currently pointed to in the buffer and stores the * Returns the sample currently pointed to in the buffer and stores the
* new sample in its place * new sample in its place
*
* @param sample * @param sample
* @return * @return
*/ */
public Complex get( Complex sample ) public Complex get(Complex sample)
{ {
Complex retVal = mBuffer[ mBufferPointer ]; Complex retVal = mBuffer[mBufferPointer];
put( sample ); put(sample);
return retVal; return retVal;
} }
public void put( Complex sample ) public void put(Complex sample)
{ {
mBuffer[ mBufferPointer ] = sample; mBuffer[mBufferPointer] = sample;
mBufferPointer++; mBufferPointer++;
if( mBufferPointer >= mBuffer.length ) if(mBufferPointer >= mBuffer.length)
{ {
mBufferPointer = 0; mBufferPointer = 0;
} }
} }
public Complex[] get( int count ) /**
* Returns the (count) oldest samples in a time ordered array
*/
public Complex[] get(int count)
{ {
Complex[] samples = new Complex[ count ]; Complex[] samples = new Complex[count];
int tempCounter = mBufferPointer; int tempCounter = mBufferPointer;
for( int x = 0; x < count; x++ ) for(int x = 0; x < count; x++)
{ {
samples[ x ] = mBuffer[ tempCounter ]; samples[x] = mBuffer[tempCounter];
tempCounter++; tempCounter++;
if( tempCounter > mBuffer.length - 1 ) if(tempCounter > mBuffer.length - 1)
{ {
tempCounter = 0; tempCounter = 0;
} }
@@ -87,4 +96,12 @@ public class ComplexCircularBuffer
return samples; return samples;
} }
/**
* Returns the samples in a time-ordered array
*/
public Complex[] getAll()
{
return get(length());
}
} }

View File

@@ -17,42 +17,63 @@
******************************************************************************/ ******************************************************************************/
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.StandardDeviation;
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 StandardDeviation mStandardDeviation;
int mBufferPointer = 0; private Variance mVariance;
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 +81,100 @@ 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);
}
public double standardDeviation()
{
if(mStandardDeviation == null)
{
mStandardDeviation = new StandardDeviation();
}
return mStandardDeviation.evaluate(mBuffer);
}
/**
* 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

@@ -25,24 +25,34 @@ import java.util.Arrays;
* fills buffer with 0-valued samples * fills buffer with 0-valued samples
* *
* Can be used as a delay-type buffer, to delay samples by the 'size' amount * Can be used as a delay-type buffer, to delay samples by the 'size' amount
* @author denny
* *
* @author denny
*/ */
public class FloatCircularBuffer public class FloatCircularBuffer
{ {
float[] mBuffer; float[] mBuffer;
int mBufferPointer = 0; int mBufferPointer = 0;
public FloatCircularBuffer( 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 FloatCircularBuffer(int size, float initialFillValue)
{ {
mBuffer = new float[ size ]; mBuffer = new float[size];
Arrays.fill(mBuffer, initialFillValue);
Arrays.fill( mBuffer, (float)0.0 );
} }
public int getSize() /**
* Creates a circular double buffer of the specified size and all entries filled with an initial value of zero.
*
* @param size of the buffer
*/
public FloatCircularBuffer(int size)
{ {
return mBuffer.length; this(size, 0.0f);
} }
public float[] getBuffer() public float[] getBuffer()
@@ -51,20 +61,20 @@ public class FloatCircularBuffer
} }
/** /**
* Puts the new value into the buffer and returns the oldest buffer value * Puts the new value into the buffer and returns the oldest buffer value that it replaced
* that it replaced *
* @param newValue * @param newValue to add to the buffer
* @return * @return oldest value that was overwritten by the new value
*/ */
public float get( float newValue ) public float get(float newValue)
{ {
float oldestSample = mBuffer[ mBufferPointer ]; float oldestSample = mBuffer[mBufferPointer];
mBuffer[ mBufferPointer ] = newValue; mBuffer[mBufferPointer] = newValue;
mBufferPointer++; mBufferPointer++;
if( mBufferPointer >= mBuffer.length ) if(mBufferPointer >= mBuffer.length)
{ {
mBufferPointer = 0; mBufferPointer = 0;
} }
@@ -72,47 +82,39 @@ public class FloatCircularBuffer
return oldestSample; return oldestSample;
} }
/** public float[] getAll()
* Convenience method to put a new value in the buffer, while discarding
* the old value
*/
public void put( float newValue )
{ {
get( newValue ); int valuePointer = 0;
float[] values = new float[mBuffer.length];
int bufferPointer = mBufferPointer;
while(valuePointer < values.length)
{
values[valuePointer++] = mBuffer[bufferPointer++];
if(bufferPointer >= mBuffer.length)
{
bufferPointer = 0;
}
}
return values;
} }
/** /**
* Returns an array of arraySize, loaded with sampleCount of the * Places the new value into the buffer, overwriting the oldest value
* oldest samples, loaded into the array starting at index 0.
* *
* This is useful for fetching an array filled half way with samples to * @param newValue to add to the buffer
* use in FFT processing.
* @param arraySize - size of the array (must be larger than sampleCount)
* @param sampleCount - number of the oldest samples in the buffer to load
* @return
*/ */
public float[] get( int arraySize, int sampleCount ) public void put(float newValue)
{ {
float[] samples = new float[ arraySize ]; mBuffer[mBufferPointer] = newValue;
if( arraySize > sampleCount ) mBufferPointer++;
if(mBufferPointer >= mBuffer.length)
{ {
int tempCounter = mBufferPointer; mBufferPointer = 0;
for( int x = 0; x < sampleCount; x++ )
{
samples[ x ] = mBuffer[ tempCounter ];
tempCounter++;
if( tempCounter > mBuffer.length )
{
tempCounter = 0;
} }
} }
}
return samples;
}
} }

View File

@@ -666,11 +666,11 @@ public class FilterFactory
* @param alpha - roll-off factor * @param alpha - roll-off factor
* @return - filter coefficients * @return - filter coefficients
*/ */
public static float[] getRootRaisedCosine(int samplesPerSymbol, public static float[] getRootRaisedCosine(float samplesPerSymbol,
int symbols, int symbols,
float alpha) float alpha)
{ {
int taps = samplesPerSymbol * symbols + 1; int taps = (int)(samplesPerSymbol * (float)symbols + 1.0f);
float scale = 0; float scale = 0;
@@ -680,8 +680,8 @@ public class FilterFactory
{ {
float index = (float) x - ((float) taps / 2.0f); float index = (float) x - ((float) taps / 2.0f);
float x1 = (float) Math.PI * index / (float) samplesPerSymbol; float x1 = (float) Math.PI * index / samplesPerSymbol;
float x2 = 4.0f * alpha * index / (float) samplesPerSymbol; float x2 = 4.0f * alpha * index / samplesPerSymbol;
float x3 = x2 * x2 - 1.0f; float x3 = x2 * x2 - 1.0f;
float numerator, denominator; float numerator, denominator;
@@ -692,7 +692,7 @@ public class FilterFactory
{ {
numerator = (float) Math.cos((1.0 + alpha) * x1) + numerator = (float) Math.cos((1.0 + alpha) * x1) +
(float) Math.sin((1.0f - alpha) * x1) / (float) Math.sin((1.0f - alpha) * x1) /
(4.0f * alpha * index / (float) samplesPerSymbol); (4.0f * alpha * index / samplesPerSymbol);
} }
else else
{ {
@@ -713,9 +713,9 @@ public class FilterFactory
x3 = (1.0f - alpha) * x1; x3 = (1.0f - alpha) * x1;
x2 = (1.0f + alpha) * x1; x2 = (1.0f + alpha) * x1;
numerator = (float) (Math.sin(x2) * (1.0f + alpha) * Math.PI - numerator = (float) (Math.sin(x2) * (1.0 + alpha) * Math.PI -
Math.cos(x3) * ((1.0 - alpha) * Math.PI * Math.cos(x3) * ((1.0 - alpha) * Math.PI *
(double) samplesPerSymbol) / (4 * alpha * index) + (double) samplesPerSymbol) / (4.0 * alpha * index) +
Math.sin(x3) * (double) samplesPerSymbol * Math.sin(x3) * (double) samplesPerSymbol *
(double) samplesPerSymbol / (4.0 * alpha * index * index)); (double) samplesPerSymbol / (4.0 * alpha * index * index));

View File

@@ -12,9 +12,11 @@ import org.jtransforms.fft.FloatFFT_1D;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import java.net.URL;
public class FilterView extends BorderPane public class FilterView extends BorderPane
{ {
private final static Logger mLog = LoggerFactory.getLogger( FilterView.class ); private final static Logger mLog = LoggerFactory.getLogger(FilterView.class);
private CurveFittedAreaChart mImpulseChart; private CurveFittedAreaChart mImpulseChart;
private NumberAxis mImpulseXAxis; private NumberAxis mImpulseXAxis;
@@ -23,22 +25,22 @@ public class FilterView extends BorderPane
private NumberAxis mDFTXAxis; private NumberAxis mDFTXAxis;
private NumberAxis mDFTYAxis; private NumberAxis mDFTYAxis;
private static final int FFT_SIZE = 4096; private static final int FFT_SIZE = 4096;
private FloatFFT_1D mFFT = new FloatFFT_1D( FFT_SIZE ); private FloatFFT_1D mFFT = new FloatFFT_1D(FFT_SIZE);
public FilterView( float[] taps ) public FilterView(float[] taps)
{ {
init(); init();
if( taps != null ) if(taps != null)
{ {
setImpulseTaps( taps ); setImpulseTaps(taps);
float[] dft = new float[ FFT_SIZE ]; float[] dft = new float[FFT_SIZE];
System.arraycopy( taps, 0, dft, 0, taps.length ); System.arraycopy(taps, 0, dft, 0, taps.length);
mFFT.realForward( dft ); mFFT.realForward(dft);
setDFTTaps( convertDFTToDecibel( dft, taps.length ) ); setDFTTaps(convertDFTToDecibel(dft, taps.length));
} }
} }
@@ -46,119 +48,131 @@ public class FilterView extends BorderPane
{ {
HBox hbox = new HBox(); HBox hbox = new HBox();
mImpulseXAxis = new NumberAxis( 0.0, 0.5, 1.0 ); mImpulseXAxis = new NumberAxis(0.0, 0.5, 1.0);
mImpulseYAxis = new NumberAxis( -0.2, 1.2, .1 ); mImpulseYAxis = new NumberAxis(-0.2, 1.2, .1);
mImpulseChart = new CurveFittedAreaChart( mImpulseXAxis, mImpulseYAxis ); mImpulseChart = new CurveFittedAreaChart(mImpulseXAxis, mImpulseYAxis);
mImpulseChart.setLegendVisible( false ); mImpulseChart.setLegendVisible(false);
mImpulseChart.setHorizontalGridLinesVisible( false ); mImpulseChart.setHorizontalGridLinesVisible(false);
mImpulseChart.setVerticalGridLinesVisible(false); mImpulseChart.setVerticalGridLinesVisible(false);
mImpulseChart.setAlternativeColumnFillVisible(false); mImpulseChart.setAlternativeColumnFillVisible(false);
mImpulseChart.setAlternativeRowFillVisible(false); mImpulseChart.setAlternativeRowFillVisible(false);
String css = FilterView.class.getResource( "FilterView.css" ).toExternalForm(); URL cssURL = FilterView.class.getResource("FilterView.css");
mImpulseChart.getStylesheets().add( css );
hbox.getChildren().add( mImpulseChart ); String css = null;
HBox.setHgrow( mImpulseChart, Priority.ALWAYS );
mDFTXAxis = new NumberAxis( 0.0, FFT_SIZE / 2, FFT_SIZE / 8 ); if(cssURL != null)
mDFTYAxis = new NumberAxis( -200.0, 10.0, 10.0 ); {
css = cssURL.toExternalForm();
mDFTChart = new CurveFittedAreaChart( mDFTXAxis, mDFTYAxis ); }
mDFTChart.setLegendVisible( false );
mDFTChart.setHorizontalGridLinesVisible( false ); hbox.getChildren().add(mImpulseChart);
HBox.setHgrow(mImpulseChart, Priority.ALWAYS);
mDFTXAxis = new NumberAxis(0.0, FFT_SIZE / 2, FFT_SIZE / 8);
mDFTYAxis = new NumberAxis(-200.0, 10.0, 10.0);
mDFTChart = new CurveFittedAreaChart(mDFTXAxis, mDFTYAxis);
mDFTChart.setLegendVisible(false);
mDFTChart.setHorizontalGridLinesVisible(false);
mDFTChart.setVerticalGridLinesVisible(false); mDFTChart.setVerticalGridLinesVisible(false);
mDFTChart.setAlternativeColumnFillVisible(false); mDFTChart.setAlternativeColumnFillVisible(false);
mDFTChart.setAlternativeRowFillVisible(false); mDFTChart.setAlternativeRowFillVisible(false);
mDFTChart.getStylesheets().add( css );
hbox.getChildren().add( mDFTChart ); if(css != null)
HBox.setHgrow( mDFTChart, Priority.ALWAYS );
setCenter( hbox );
}
public void setImpulseTaps( double[] taps )
{ {
float[] convertedTaps = new float[ taps.length ]; mImpulseChart.getStylesheets().add(css);
mDFTChart.getStylesheets().add(css);
}
for( int x = 0; x < taps.length; x++ ) hbox.getChildren().add(mDFTChart);
HBox.setHgrow(mDFTChart, Priority.ALWAYS);
setCenter(hbox);
}
public void setImpulseTaps(double[] taps)
{ {
convertedTaps[ x ] = (float)taps[ x ]; float[] convertedTaps = new float[taps.length];
for(int x = 0; x < taps.length; x++)
{
convertedTaps[x] = (float)taps[x];
} }
setImpulseTaps( convertedTaps ); setImpulseTaps(convertedTaps);
} }
public void setImpulseTaps( float[] taps ) public void setImpulseTaps(float[] taps)
{ {
double smallest = 0.0; double smallest = 0.0;
double largest = 0.0; double largest = 0.0;
final XYChart.Series<Number, Number> series = new XYChart.Series<>(); final XYChart.Series<Number,Number> series = new XYChart.Series<>();
for( int x = 0; x < taps.length; x++ ) for(int x = 0; x < taps.length; x++)
{ {
if( taps[ x ] < smallest ) if(taps[x] < smallest)
{ {
smallest = taps[ x ]; smallest = taps[x];
} }
if( taps[ x ] > largest ) if(taps[x] > largest)
{ {
largest = taps[ x ]; largest = taps[x];
} }
series.getData().add( new XYChart.Data<Number, Number>( x, taps[ x ] ) ); series.getData().add(new XYChart.Data<Number,Number>(x, taps[x]));
} }
mImpulseXAxis.setLowerBound( 0.0 ); mImpulseXAxis.setLowerBound(0.0);
mImpulseXAxis.setUpperBound( taps.length - 1 ); mImpulseXAxis.setUpperBound(taps.length - 1);
mImpulseXAxis.setTickUnit( 1.0 ); mImpulseXAxis.setTickUnit(1.0);
double padding = Math.abs( largest - smallest ) * .1; double padding = Math.abs(largest - smallest) * .1;
mImpulseYAxis.setLowerBound( smallest - padding ); mImpulseYAxis.setLowerBound(smallest - padding);
mImpulseYAxis.setUpperBound( largest + padding ); mImpulseYAxis.setUpperBound(largest + padding);
mImpulseYAxis.setTickUnit( padding ); mImpulseYAxis.setTickUnit(padding);
ObservableList<Series<Number,Number>> list = mImpulseChart.getData(); ObservableList<Series<Number,Number>> list = mImpulseChart.getData();
list.add( series ); list.add(series);
} }
public void setDFTTaps( float[] taps ) public void setDFTTaps(float[] taps)
{ {
double smallest = 0.0; double smallest = 0.0;
final XYChart.Series<Number, Number> series = new XYChart.Series<>(); final XYChart.Series<Number,Number> series = new XYChart.Series<>();
for( int x = 0; x < taps.length; x++ ) for(int x = 0; x < taps.length; x++)
{ {
if( taps[ x ] < smallest ) if(taps[x] < smallest)
{ {
smallest = taps[ x ]; smallest = taps[x];
} }
series.getData().add( new XYChart.Data<Number, Number>( x, taps[ x ] ) ); series.getData().add(new XYChart.Data<Number,Number>(x, taps[x]));
} }
ObservableList<Series<Number,Number>> list = mDFTChart.getData(); ObservableList<Series<Number,Number>> list = mDFTChart.getData();
list.add( series ); list.add(series);
} }
public float[] convertDFTToDecibel( float[] dft, int tapLength ) public float[] convertDFTToDecibel(float[] dft, int tapLength)
{ {
float[] decibels = new float[ dft.length / 2 ]; float[] decibels = new float[dft.length / 2];
int index = 0; int index = 0;
for( int x = 0; x < decibels.length; x ++ ) for(int x = 0; x < decibels.length; x++)
{ {
index = x * 2; index = x * 2;
decibels[ x ] = 20.0f * (float)Math.log10( ( ( dft[ index ] * dft[ index ] ) + decibels[x] = 20.0f * (float)Math.log10(((dft[index] * dft[index]) +
( dft[ index + 1 ] * dft[ index + 1 ] ) ) ); (dft[index + 1] * dft[index + 1])));
} }
return decibels; return decibels;

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(48000)
.gridDensity(16) .passBandCutoff(5100)
.passBandCutoff(2500)
.passBandAmplitude(1.0) .passBandAmplitude(1.0)
.passBandRipple(0.01) .passBandRipple(0.01)
.stopBandStart(4000)
.stopBandAmplitude(0.0) .stopBandAmplitude(0.0)
.stopBandRipple(0.008) .stopBandStart(6500)
.stopBandRipple(0.01)
.build(); .build();
// FIRFilterSpecification specification = FIRFilterSpecification.highPassBuilder() // FIRFilterSpecification specification = FIRFilterSpecification.highPassBuilder()
@@ -72,6 +81,9 @@ public class FilterViewer extends Application
float[] taps = null; float[] taps = null;
// taps = FilterFactory.getSinc(6000, 1920, 47, Window.WindowType.BLACKMAN);
// taps = FilterFactory.getRootRaisedCosine(10, 10, 0.2f);
// taps = FilterFactory.getLowPass(48000, 6750, 7500, 60, // taps = FilterFactory.getLowPass(48000, 6750, 7500, 60,
// Window.WindowType.HAMMING, true); // Window.WindowType.HAMMING, true);

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

@@ -5,54 +5,86 @@ import org.apache.commons.lang3.Validate;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import java.text.DecimalFormat;
import java.util.Arrays;
public class RealInterpolator extends Interpolator public class RealInterpolator extends Interpolator
{ {
private final static Logger mLog = LoggerFactory.getLogger( RealInterpolator.class ); private final static Logger mLog = LoggerFactory.getLogger(RealInterpolator.class);
private float mGain; private float mGain;
public RealInterpolator( float gain ) /**
* Provides an interpolated sample point along an eight-sample waveform representation using 128 filters to
* provide approximate interpolation with a resolution of 1/128th of a sample.
*
* @param gain to apply to the interpolated sample
*/
public RealInterpolator(float gain)
{ {
mGain = gain; mGain = gain;
} }
/** /**
* Calculates an interpolated value from the 8 samples beginning at the * Calculates an interpolated value from eight samples that start at the offset into the sample array. The
* offset index. Uses the mu value to determine which of 128 filter kernels * interpolated sample will fall within the middle of the eight sample array, between indexes offset+3 and
* to use in order to closely approximate the ideal frequency response for * offset+4. The mu argument is translated into an index position between 0 and 128, where a mu of 0.0 will be
* the value of mu, ranging from 0.0 to 1.0, indicating the interpolated * converted to index zero and will be equal to the sample at index offset+3 and a mu of 1.0 will be equal to
* position in the sample set ranging from offset to offset + 7. * the sample at offset+4. All mu values between 0.0 and 1.0 will be converted to a 1 - 127 index and will
* produce an approximated value from among 127 interpolated sample points between indexes offset+3 and offset+4.
* *
* @param samples - sample array of length at least offset + 7 * @param samples - sample array of length at least offset + 7
* * @param mu - interpolated sample position between 0.0 and 1.0
* @param mu - interpolated sample position between 0 and 1.0
*
* @return - interpolated sample value * @return - interpolated sample value
*/ */
public float filter( float[] samples, int offset, float mu ) public float filter(float[] samples, int offset, float mu)
{ {
/* Ensure we have enough samples in the array */ /* Ensure we have enough samples in the array */
Validate.isTrue(samples.length >= offset + 7); Validate.isTrue(samples.length >= offset + 7);
/* Identify the filter bank that corresponds to mu */ /* Identify the filter bank that corresponds to mu */
int index = (int)( NSTEPS * mu ); int index = (int)(NSTEPS * mu);
float accumulator = ( TAPS[ index ][ 7 ] * samples[ offset ] ); float accumulator = (TAPS[index][7] * samples[offset]);
accumulator += ( TAPS[ index ][ 6 ] * samples[ offset + 1 ] ); accumulator += (TAPS[index][6] * samples[offset + 1]);
accumulator += ( TAPS[ index ][ 5 ] * samples[ offset + 2 ] ); accumulator += (TAPS[index][5] * samples[offset + 2]);
accumulator += ( TAPS[ index ][ 4 ] * samples[ offset + 3 ] ); accumulator += (TAPS[index][4] * samples[offset + 3]);
accumulator += ( TAPS[ index ][ 3 ] * samples[ offset + 4 ] ); accumulator += (TAPS[index][3] * samples[offset + 4]);
accumulator += ( TAPS[ index ][ 2 ] * samples[ offset + 5 ] ); accumulator += (TAPS[index][2] * samples[offset + 5]);
accumulator += ( TAPS[ index ][ 1 ] * samples[ offset + 6 ] ); accumulator += (TAPS[index][1] * samples[offset + 6]);
accumulator += ( TAPS[ index ][ 0 ] * samples[ offset + 7 ] ); accumulator += (TAPS[index][0] * samples[offset + 7]);
return accumulator * mGain; return accumulator * mGain;
} }
public Complex filter( float[] iSamples, float[] qSamples, int offset, float mu ) public Complex filter(float[] iSamples, float[] qSamples, int offset, float mu)
{ {
float i = filter( iSamples, offset, mu ); float i = filter(iSamples, offset, mu);
float q = filter( qSamples, offset, mu ); float q = filter(qSamples, offset, mu);
return new Complex(i, q);
}
public static void main(String[] args)
{
RealInterpolator interpolator = new RealInterpolator(1.0f);
DecimalFormat decimalFormat = new DecimalFormat("0.0000");
double TWO_PI = Math.PI * 2.0;
float[] samples = new float[16];
for(int x = 0; x < 16; x++)
{
samples[x] = (float)Math.sin(TWO_PI * (double)x / 8.0);
}
mLog.debug("Samples: " + Arrays.toString(samples));
for(float x = 0.0f; x <= 1.01f; x += 0.1f)
{
mLog.debug(decimalFormat.format(x) + ": " + decimalFormat.format(interpolator.filter(samples, 1, x)));
}
return new Complex( i, q );
} }
} }

View File

@@ -17,18 +17,20 @@
******************************************************************************/ ******************************************************************************/
package io.github.dsheirer.dsp.fm; package io.github.dsheirer.dsp.fm;
import io.github.dsheirer.sample.complex.Complex;
public abstract class FMDemodulator public abstract class FMDemodulator
{ {
private float mPreviousI = 0.0f; private float mPreviousI = 0.0f;
private float mPreviousQ = 0.0f; private float mPreviousQ = 0.0f;
protected float mGain; protected float mGain;
public FMDemodulator( float gain ) public FMDemodulator(float gain)
{ {
mGain = gain; mGain = gain;
} }
public float demodulate( float currentI, float currentQ ) public float demodulate(float currentI, float currentQ)
{ {
/** /**
* Multiply the current sample against the complex conjugate of the * Multiply the current sample against the complex conjugate of the
@@ -36,13 +38,13 @@ public abstract class FMDemodulator
* *
* Negating the previous sample quadrature produces the conjugate * Negating the previous sample quadrature produces the conjugate
*/ */
double inphase = ( currentI * mPreviousI ) - ( currentQ * -mPreviousQ ); double inphase = (currentI * mPreviousI) - (currentQ * -mPreviousQ);
double quadrature = ( currentQ * mPreviousI ) + ( currentI * -mPreviousQ ); double quadrature = (currentQ * mPreviousI) + (currentI * -mPreviousQ);
double angle = 0.0f; double angle = 0.0f;
//Check for divide by zero //Check for divide by zero
if( inphase != 0 ) if(inphase != 0)
{ {
/** /**
* Use the arc-tangent of quadrature divided by inphase to * Use the arc-tangent of quadrature divided by inphase to
@@ -51,7 +53,7 @@ public abstract class FMDemodulator
* serves as the instantaneous amplitude of the demodulated signal * serves as the instantaneous amplitude of the demodulated signal
*/ */
double denominator = 1.0d / inphase; double denominator = 1.0d / inphase;
angle = Math.atan( (double)quadrature * denominator ); angle = Math.atan((double)quadrature * denominator);
} }
/** /**
@@ -60,7 +62,30 @@ public abstract class FMDemodulator
mPreviousI = currentI; mPreviousI = currentI;
mPreviousQ = currentQ; mPreviousQ = currentQ;
return (float)( angle * mGain ); return (float)(angle * mGain);
}
public static double demodulate(Complex previous, Complex current)
{
double inphase = (current.inphase() * previous.inphase()) - (current.quadrature() * -previous.quadrature());
double quadrature = (current.quadrature() * previous.inphase()) + (current.inphase() * -previous.quadrature());
double angle = 0.0f;
//Check for divide by zero
if(inphase != 0)
{
/**
* Use the arc-tangent of quadrature divided by inphase to
* get the phase angle (+/-) which was directly manipulated by the
* original message waveform during the modulation. This value now
* serves as the instantaneous amplitude of the demodulated signal
*/
double denominator = 1.0d / inphase;
angle = Math.atan((double)quadrature * denominator);
}
return angle;
} }
public abstract void dispose(); public abstract void dispose();
@@ -71,7 +96,7 @@ public abstract class FMDemodulator
mPreviousQ = 0.0f; mPreviousQ = 0.0f;
} }
public void setGain( float gain ) public void setGain(float gain)
{ {
mGain = gain; mGain = gain;
} }

View File

@@ -26,8 +26,7 @@ import org.slf4j.LoggerFactory;
public class FMDemodulator_CB extends FMDemodulator implements Listener<ComplexBuffer> public class FMDemodulator_CB extends FMDemodulator implements Listener<ComplexBuffer>
{ {
private final static Logger mLog = private final static Logger mLog = LoggerFactory.getLogger( FMDemodulator_CB.class );
LoggerFactory.getLogger( FMDemodulator_CB.class );
private Listener<RealBuffer> mListener; private Listener<RealBuffer> 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

@@ -8,23 +8,30 @@ public class ComplexGain implements Listener<Complex>
private float mGain; private float mGain;
private Listener<Complex> mListener; private Listener<Complex> mListener;
public ComplexGain( float gain ) public ComplexGain(float gain)
{ {
mGain = gain; mGain = gain;
} }
public Complex apply(Complex sample)
{
sample.multiply(mGain);
return sample;
}
@Override @Override
public void receive( Complex sample ) public void receive(Complex sample)
{ {
if( mListener != null ) if(mListener != null)
{ {
sample.multiply( mGain ); apply(sample);
mListener.receive( sample ); mListener.receive(sample);
} }
} }
public void setListener( Listener<Complex> listener ) public void setListener(Listener<Complex> listener)
{ {
mListener = listener; mListener = listener;
} }

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,162 @@
/*******************************************************************************
* 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;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class DQPSKDemodulator implements ComplexSampleListener
{
private final static Logger mLog = LoggerFactory.getLogger(DQPSKDemodulator.class);
protected InterpolatingSampleBuffer mInterpolatingSampleBuffer;
protected IPhaseLockedLoop mPLL;
protected DQPSKSymbolEvaluator mSymbolEvaluator = new DQPSKSymbolEvaluator();
private Complex mReceivedSample = new Complex(0, 0);
private Complex mPreviousPrecedingSample = new Complex(0, 0);
private Complex mPreviousCurrentSample = new Complex(0, 0);
private Complex mPrecedingSample = new Complex(0, 0);
private Complex mCurrentSample = new Complex(0, 0);
private Complex mPrecedingSymbol = new Complex(0, 0);
protected Complex mCurrentSymbol = new Complex(0, 0);
private Listener<Dibit> mDibitListener;
/**
* Decoder for Differential Quaternary Phase Shift Keying (DQPSK). This decoder uses both a Costas Loop (PLL) and
* a custom DQPSK symbol timing error detector to automatically align to the incoming carrier frequency and to
* adjust for any changes in symbol timing.
*
* This detector is optimized for constant amplitude DQPSK symbols like C4FM.
*
* @param phaseLockedLoop for tracking carrier frequency error
* @param interpolatingSampleBuffer to hold samples for interpolating a symbol
*/
public DQPSKDemodulator(IPhaseLockedLoop phaseLockedLoop, InterpolatingSampleBuffer interpolatingSampleBuffer)
{
mPLL = phaseLockedLoop;
mInterpolatingSampleBuffer = interpolatingSampleBuffer;
}
/**
* Processes a (filtered) 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]);
}
}
/**
* Processes a complex sample for decoding. Once sufficient samples are buffered, a symbol decision is made.
* @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
mReceivedSample.setValues(inphase, quadrature);
//Mix current sample with costas loop to remove any rotation that is present from a mis-tuned carrier frequency
mReceivedSample.multiply(mPLL.incrementAndGetCurrentVector());
//Store the sample in the interpolating buffer
mInterpolatingSampleBuffer.receive(mReceivedSample);
//Calculate the symbol once we've stored enough samples
if(mInterpolatingSampleBuffer.hasSymbol())
{
calculateSymbol();
}
}
/**
* Calculates a symbol from the interpolating buffer
*/
protected void calculateSymbol()
{
//Get preceding sample and an interpolated current sample from the interpolating buffer
mPrecedingSample = mInterpolatingSampleBuffer.getPrecedingSample();
mCurrentSample = mInterpolatingSampleBuffer.getCurrentSample();
//Calculate preceding, current and following symbols as the delta rotation compared to the previous samples
mPrecedingSymbol.setInphase(Complex.multiplyInphase(mPrecedingSample.inphase(), mPrecedingSample.quadrature(),
mPreviousPrecedingSample.inphase(), -mPreviousPrecedingSample.quadrature()));
mPrecedingSymbol.setQuadrature(Complex.multiplyQuadrature(mPrecedingSample.inphase(), mPrecedingSample.quadrature(),
mPreviousPrecedingSample.inphase(), -mPreviousPrecedingSample.quadrature()));
mCurrentSymbol.setInphase(Complex.multiplyInphase(mCurrentSample.inphase(), mCurrentSample.quadrature(),
mPreviousCurrentSample.inphase(), -mPreviousCurrentSample.quadrature()));
mCurrentSymbol.setQuadrature(Complex.multiplyQuadrature(mCurrentSample.inphase(), mCurrentSample.quadrature(),
mPreviousCurrentSample.inphase(), -mPreviousCurrentSample.quadrature()));
//Set gain to unity before we calculate the error value
mPrecedingSymbol.normalize();
mCurrentSymbol.normalize();
mSymbolEvaluator.setSymbol(mPrecedingSymbol, mCurrentSymbol);
mInterpolatingSampleBuffer.resetAndAdjust(mSymbolEvaluator.getTimingError());
//Store current samples/symbols to use for the next period
mPreviousPrecedingSample.setValues(mPrecedingSample);
mPreviousCurrentSample.setValues(mCurrentSample);
//Calculate the phase error of the current symbol relative to the expected constellation and provide
//feedback to the PLL
mPLL.adjust(clip(mSymbolEvaluator.getPhaseError(), 0.5f));
if(mDibitListener != null)
{
mDibitListener.receive(mSymbolEvaluator.getSymbolDecision());
}
}
/**
* Registers the listener to receive dibit symbol decisions from this demodulator
*/
public void setDibitListener(Listener<Dibit> listener)
{
mDibitListener = listener;
}
/**
* 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,131 @@
/*******************************************************************************
* 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.CostasLoop;
import io.github.dsheirer.dsp.psk.pll.IPhaseLockedLoop;
import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.complex.Complex;
public class DQPSKDemodulatorInstrumented extends DQPSKDemodulator
{
private Listener<SymbolDecisionData> mSymbolDecisionDataListener;
private Listener<Double> mSamplesPerSymbolListener;
private Listener<Complex> mSymbolListener;
private Listener<Double> mPLLErrorListener;
private Listener<Double> mPLLFrequencyListener;
private double mSampleRate;
/**
* Decoder for Differential Quaternary Phase Shift Keying (DQPSK). This decoder uses both a Costas Loop (PLL) and
* a custom DQPSK symbol timing error detector to automatically align to the incoming carrier frequency and to
* adjust for any changes in symbol timing.
*
* This detector is optimized for constant amplitude DQPSK symbols like C4FM.
*
* @param phaseLockedLoop for tracking carrier frequency error
* @param interpolatingSampleBuffer
* @param sampleRate of the incoming complex sample stream
*/
public DQPSKDemodulatorInstrumented(IPhaseLockedLoop phaseLockedLoop,
InterpolatingSampleBufferInstrumented interpolatingSampleBuffer,
double sampleRate)
{
super(phaseLockedLoop, interpolatingSampleBuffer);
mSampleRate = sampleRate;
}
/**
* Overrides the parent class symbol calculation to capture eye diagram data
*/
protected void calculateSymbol()
{
//Eye diagram listener
if(mSymbolDecisionDataListener != null)
{
mSymbolDecisionDataListener.receive(
((InterpolatingSampleBufferInstrumented)mInterpolatingSampleBuffer).getSymbolDecisionData());
}
super.calculateSymbol();
if(mSamplesPerSymbolListener != null)
{
mSamplesPerSymbolListener.receive((double)mInterpolatingSampleBuffer.getSamplingPoint());
}
//Send to an external constellation symbol listener when registered
if(mSymbolListener != null)
{
mSymbolListener.receive(mCurrentSymbol);
}
if(mPLLErrorListener != null)
{
mPLLErrorListener.receive((double)mSymbolEvaluator.getPhaseError());
}
if(mPLLFrequencyListener != null)
{
double loopFrequency = ((CostasLoop)mPLL).getLoopFrequency();
loopFrequency *= mSampleRate / (2.0 * Math.PI);
mPLLFrequencyListener.receive(loopFrequency);
}
}
/**
* Registers a listener to receive symbol decision data to produce an eye diagram.
*/
public void setSymbolDecisionDataListener(Listener<SymbolDecisionData> listener)
{
mSymbolDecisionDataListener = listener;
}
/**
* Registers the listener to receive PLL error values
*/
public void setSamplesPerSymbolListener(Listener<Double> listener)
{
mSamplesPerSymbolListener = listener;
}
/**
* Registers the listener to receive decoded QPSK symbols
*/
public void setSymbolListener(Listener<Complex> listener)
{
mSymbolListener = listener;
}
/**
* Registers the listener to receive PLL error values
*/
public void setPLLErrorListener(Listener<Double> listener)
{
mPLLErrorListener = listener;
}
/**
* Registers the listener to receive PLL error values
*/
public void setPLLFrequencyListener(Listener<Double> listener)
{
mPLLFrequencyListener = listener;
}
}

View File

@@ -0,0 +1,137 @@
/*******************************************************************************
* 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 DQPSKSymbolEvaluator implements IDQPSKSymbolEvaluator
{
private static final Complex ROTATE_FROM_PLUS_135 = Complex.fromAngle(-3.0 * Math.PI / 4.0);
private static final Complex ROTATE_FROM_PLUS_45 = Complex.fromAngle(-1.0 * Math.PI / 4.0);
private static final Complex ROTATE_FROM_MINUS_45 = Complex.fromAngle(1.0 * Math.PI / 4.0);
private static final Complex ROTATE_FROM_MINUS_135 = Complex.fromAngle(3.0 * Math.PI / 4.0);
private Complex mSymbolError = new Complex(0, 0);
private float mPhaseError = 0.0f;
private float mTimingError = 0.0f;
private float mTimingErrorPolarity = 1.0f;
private Dibit mSymbolDecision = Dibit.D00_PLUS_1;
/**
* Decision-directed symbol phase and timing error detector and symbol decision slicer.
*
* Symbol decision is based on the closest reference quadrant for the sampled symbol.
*
* Phase and timing error are calculated as the angular distance of the sampled symbol from the reference
* symbol. Timing error is further corrected to compensate for clock-wise or counter-clock-wise vector rotation
* relative to the immediately preceding symbol.
*/
public DQPSKSymbolEvaluator()
{
}
/**
* Sets the preceding and current symbols to be evaluated for phase and timing errors and to determine the
* transmitted symbol relative to the closest reference symbol. After invoking this method, you can access the
* phase and timing errors and the symbol decision via their respective accessor methods.
*
* Phase and timing error values are calculated by first determining the symbol and then calculating the phase
* and timing errors relative to the reference symbol. The timing error is corrected with the appropriate sign
* relative to the angular vector rotation so that the error value indicates the correct error direction.
*
* @param preceding differential-decoded sample/symbol used to detect rotation - does NOT need to be interpolated
* since it's only a reference
* @param current symbol to be evaluated - interpolated
*/
@Override
public void setSymbol(Complex preceding, Complex current)
{
mSymbolError.setValues(current);
if(mSymbolError.quadrature() > 0.0f)
{
if(mSymbolError.inphase() > 0.0f)
{
mSymbolDecision = Dibit.D00_PLUS_1;
mTimingErrorPolarity = (preceding.quadrature() > current.quadrature() ? 1.0f : -1.0f);
mSymbolError.multiply(ROTATE_FROM_PLUS_45);
}
else
{
mSymbolDecision = Dibit.D01_PLUS_3;
mTimingErrorPolarity = (preceding.quadrature() < current.quadrature() ? 1.0f : -1.0f);
mSymbolError.multiply(ROTATE_FROM_PLUS_135);
}
}
else
{
if(mSymbolError.inphase() > 0.0f)
{
mSymbolDecision = Dibit.D10_MINUS_1;
mTimingErrorPolarity = (preceding.quadrature() > current.quadrature() ? 1.0f : -1.0f);
mSymbolError.multiply(ROTATE_FROM_MINUS_45);
}
else
{
mSymbolDecision = Dibit.D11_MINUS_3;
mTimingErrorPolarity = (preceding.quadrature() < current.quadrature() ? 1.0f : -1.0f);
mSymbolError.multiply(ROTATE_FROM_MINUS_135);
}
}
//Since we've rotated the error symbol back to 0 radians, the quadrature value closely approximates the
//arctan of the error angle relative to 0 radians and this provides our error value
mPhaseError = -mSymbolError.quadrature();
//Timing error is the same as phase error with the sign corrected according to the vector's angular rotation
mTimingError = mSymbolError.quadrature() * mTimingErrorPolarity;
}
/**
* Phase error of the symbol relative to the nearest reference symbol.
*
* @return phase error in radians of distance from the reference symbol.
*/
@Override
public float getPhaseError()
{
return mPhaseError;
}
/**
* Timing error of the symbol relative to the nearest reference symbol.
*
* @return timing error in radians of angular distance from the reference symbol recognizing that the symbol
* originates at zero radians and rotates toward the intended reference symbol, therefore the error value indicates
* if the symbol was sampled early (-) or late (+) relative to the reference symbol.
*/
@Override
public float getTimingError()
{
return mTimingError;
}
/**
* Reference symbol that is closest to the transmitted/sampled symbol.
*/
@Override
public Dibit getSymbolDecision()
{
return mSymbolDecision;
}
}

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 = (Math.abs(previous.inphase()) - Math.abs(current.inphase())) * Math.abs(middle.inphase());
mErrorQuadrature = (Math.abs(previous.quadrature()) - Math.abs(current.quadrature())) * Math.abs(middle.quadrature());
mError = normalize(mErrorInphase + mErrorQuadrature, 1.0f);
return mError;
}
/**
* Constrains timing error to +/- the maximum value and corrects any floating point invalid numbers
*/
public static float normalize(float error, float maximum)
{
if(Float.isNaN(error))
{
return 0.0f;
}
else
{
return clip(error, maximum);
}
}
/**
* Constrains value to the range of ( -maximum <> maximum )
*/
public static float clip(float value, float maximum)
{
if(value > maximum)
{
return maximum;
}
else if(value < -maximum)
{
return -maximum;
}
return value;
}
}

View File

@@ -0,0 +1,50 @@
/*******************************************************************************
* 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 IDQPSKSymbolEvaluator
{
/**
* Sets the sampled symbol to be evaluated. Note: the symbol's gain value MUST be normalized to the unit circle.
*
* @param preceding symbol used to detect (counter-)clock-wise rotation
* @param symbol currently being sampled
*/
void setSymbol(Complex preceding, Complex symbol);
/**
* Phase error of the symbol relative to the closest reference symbol
* @return angular phase error in radians
*/
float getPhaseError();
/**
* Timing error of the symbol relative to the closest reference symbol
* @return angular timing error in radians where a positive value indicates early sampling and sample timing needs
* to be increased and a negative value indicates late sampling where sample timing needs to be decreased.
*/
float getTimingError();
/**
* Dibit decision indicating the reference symbol location closest to the symbol.
* @return symbol decision
*/
Dibit getSymbolDecision();
}

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,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.sample.complex.Complex;
public interface ISymbolPhaseErrorCalculator
{
/**
* Calculates the phase error of the symbol relative to an alignment for the constellation
* @param symbol to calculate error
* @return error value
*/
float getPhaseError(Complex symbol);
}

View File

@@ -0,0 +1,167 @@
/*******************************************************************************
* 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 InterpolatingSampleBuffer
{
private static final float MAXIMUM_DEVIATION_SAMPLES_PER_SYMBOL = 0.02f; // +/- 2% deviation
private Complex mPrecedingSample = new Complex(0,0);
private Complex mCurrentSample = new Complex(0,0);
private float[] mDelayLineInphase;
private float[] mDelayLineQuadrature;
private int mDelayLinePointer = 0;
private int mTwiceSamplesPerSymbol;
private float mSamplingPoint;
private float mSampleCounterGain = 1.0f;
private float mDetectedSamplesPerSymbol;
private float mDetectedSamplesPerSymbolGain = 0.1f * mSampleCounterGain * mSampleCounterGain;
private float mMaximumSamplesPerSymbol;
private float mMinimumSamplesPerSymbol;
private RealInterpolator mInterpolator = new RealInterpolator(1.0f);
/**
* Buffer to store complex sample data and produce interpolated samples.
* @param samplesPerSymbol
*/
public InterpolatingSampleBuffer(float samplesPerSymbol)
{
mSamplingPoint = samplesPerSymbol;
mDetectedSamplesPerSymbol = samplesPerSymbol;
mMaximumSamplesPerSymbol = samplesPerSymbol * (1.0f + MAXIMUM_DEVIATION_SAMPLES_PER_SYMBOL);
mMinimumSamplesPerSymbol = samplesPerSymbol * (1.0f - MAXIMUM_DEVIATION_SAMPLES_PER_SYMBOL);
mTwiceSamplesPerSymbol = (int)Math.floor(2.0 * samplesPerSymbol);
mDelayLineInphase = new float[2 * mTwiceSamplesPerSymbol];
mDelayLineQuadrature = new float[2 * mTwiceSamplesPerSymbol];
}
/**
* Stores the sample in the buffer and updates pointers.
* @param sample
*/
public void receive(Complex sample)
{
mSamplingPoint--;
//Fill up the delay line to use with the interpolator
mDelayLineInphase[mDelayLinePointer] = sample.inphase();
mDelayLineInphase[mDelayLinePointer + mTwiceSamplesPerSymbol] = sample.inphase();
mDelayLineQuadrature[mDelayLinePointer] = sample.quadrature();
mDelayLineQuadrature[mDelayLinePointer + mTwiceSamplesPerSymbol] = sample.quadrature();
//Increment pointer and keep pointer in bounds
mDelayLinePointer++;
mDelayLinePointer = mDelayLinePointer % 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)
{
mSamplingPoint += 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)
{
//Adjust detected samples per symbol based on timing error
mDetectedSamplesPerSymbol = mDetectedSamplesPerSymbol + (symbolTimingError * mDetectedSamplesPerSymbolGain);
//Constrain detected samples per symbol to min/max values
if(mDetectedSamplesPerSymbol > mMaximumSamplesPerSymbol)
{
mDetectedSamplesPerSymbol = mMaximumSamplesPerSymbol;
}
if(mDetectedSamplesPerSymbol < mMinimumSamplesPerSymbol)
{
mDetectedSamplesPerSymbol = mMinimumSamplesPerSymbol;
}
//Add another symbol's worth of samples to the counter and adjust timing based on gardner error
increaseSampleCounter((mDetectedSamplesPerSymbol + (symbolTimingError * mSampleCounterGain)));
}
/**
* Current value of the detected samples per symbol
*/
public float getSamplingPoint()
{
return mSamplingPoint;
}
/**
* Indicates if this buffer has accumulated a enough samples to represent a full symbol
*/
public boolean hasSymbol()
{
return mSamplingPoint < 1.0f;
}
/**
* Un-interpolated sample that precedes the current interpolated sampling point. The current sampling point falls
* somewhere between sample index 3 and index 4, therefore the preceding sample is located at index 3.
*/
public Complex getPrecedingSample()
{
mPrecedingSample.setValues(mDelayLineInphase[mDelayLinePointer + 4], mDelayLineQuadrature[mDelayLinePointer + 3]);
return mPrecedingSample;
}
/**
* 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 getCurrentSample()
{
/* Calculate interpolated current sample */
mCurrentSample.setValues(getInphase(mSamplingPoint), getQuadrature(mSamplingPoint));
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 + 1, 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 + 1, interpolation);
}
}

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;
import io.github.dsheirer.sample.complex.Complex;
public class InterpolatingSampleBufferInstrumented extends InterpolatingSampleBuffer
{
private SymbolDecisionData mSymbolDecisionData;
public InterpolatingSampleBufferInstrumented(float samplesPerSymbol)
{
super(samplesPerSymbol);
mSymbolDecisionData = new SymbolDecisionData((int)samplesPerSymbol);
}
public void receive(Complex sample)
{
super.receive(sample);
mSymbolDecisionData.receive(sample);
}
/**
* Contents of the interpolating buffer and the current buffer index and symbol decision offset. This data can
* be used to support an external eye-diagram chart.
* @return symbol decision data.
*/
public SymbolDecisionData getSymbolDecisionData()
{
mSymbolDecisionData.setSamplingPoint(getSamplingPoint());
return mSymbolDecisionData;
}
}

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,33 @@ public class LSMDemodulator implements Instrumentable, ComplexSampleListener
unwrapPhase(); unwrapPhase();
} }
@Override
public void reset()
{
mLoopPhase = 0.0f;
mLoopFrequency = 0.0f;
}
@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 +487,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 +515,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 +533,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 +551,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 +568,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 +585,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

@@ -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,17 +20,16 @@ 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 QPSKStarSlicer implements Listener<Complex> public class QPSKStarSlicer implements IQPSKSymbolDecoder, Listener<Complex>
{ {
private Broadcaster<Dibit> mBroadcaster = new Broadcaster<Dibit>(); private Broadcaster<Dibit> mBroadcaster = new Broadcaster<Dibit>();
/** /**
* Slices a ComplexSample representing a phase shifted symbol according to * Slices a Complex sample representing a phase shifted symbol according to the following constellation pattern:
* the following constellation pattern:
* *
* 00 | 01 * 00 +3 | 01 +1
* ---|--- * ------|------
* 10 | 11 * 10 -1 | 11 -1
*/ */
public QPSKStarSlicer() public QPSKStarSlicer()
{ {
@@ -27,25 +41,26 @@ public class QPSKStarSlicer implements Listener<Complex>
mBroadcaster = null; mBroadcaster = null;
} }
public void addListener( Listener<Dibit> listener ) public void addListener(Listener<Dibit> listener)
{ {
mBroadcaster.addListener( listener ); mBroadcaster.addListener(listener);
} }
public void removeListener( Listener<Dibit> listener ) public void removeListener(Listener<Dibit> listener)
{ {
mBroadcaster.removeListener( listener ); mBroadcaster.removeListener(listener);
} }
@Override @Override
public void receive( Complex sample ) public void receive(Complex sample)
{ {
mBroadcaster.broadcast( decide( sample ) ); mBroadcaster.broadcast(decode(sample));
} }
public static Dibit decide( Complex sample ) @Override
public Dibit decode(Complex sample)
{ {
if( sample.inphase() > 0 ) if(sample.inphase() > 0)
{ {
return sample.quadrature() > 0 ? Dibit.D00_PLUS_1 : Dibit.D10_MINUS_1; return sample.quadrature() > 0 ? Dibit.D00_PLUS_1 : Dibit.D10_MINUS_1;
} }

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,57 @@
/*******************************************************************************
* 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 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,93 @@
/*******************************************************************************
* 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.buffer.ComplexCircularBuffer;
import io.github.dsheirer.sample.complex.Complex;
public class SymbolDecisionData
{
//45 degrees rotation to orient the symbol to a polar axis to make error calculation easy/efficient
public static final Complex DIFFERENTIAL_OFFSET = Complex.fromAngle(Math.PI / 4.0d);
private ComplexCircularBuffer mBuffer;
private float mSamplingPoint;
/**
* Circular buffer for capturing two symbols worth of sample data for use in instrumentation.
* @param samplesPerSymbol to size the buffer
*/
public SymbolDecisionData(int samplesPerSymbol)
{
mBuffer = new ComplexCircularBuffer(2 * samplesPerSymbol);
}
/**
* Stores the complex sample in the buffer
*/
public void receive(float inphase, float quadrature)
{
mBuffer.put(new Complex(inphase, quadrature));
}
/**
* Stores the complex sample in the buffer
*/
public void receive(Complex complex)
{
mBuffer.put(complex.copy());
}
/**
* Sets the fractional sampling point for the current symbol to use in interpolating the current symbol.
*/
public void setSamplingPoint(float samplingPoint)
{
mSamplingPoint = samplingPoint;
}
/**
* Fractional sampling point
*/
public float getSamplingPoint()
{
return mSamplingPoint;
}
/**
* Array of demodulated samples representing the current symbol where each current sample is demodulated against
* the previous symbol's sample to produce the differential demodulated sample. Samples are in time order.
*
* Note: differential decoding is on an integral samples-per-symbol basis and does not use fractional interpolation.
*/
public Complex[] getDemodulated()
{
Complex[] samples = mBuffer.getAll();
int length = samples.length / 2;
Complex[] demodulated = new Complex[length];
for(int x = 0; x < samples.length / 2; x++)
{
Complex copy = samples[length + x].copy();
copy.multiply(samples[x].conjugate());
demodulated[x] = copy;
}
return demodulated;
}
}

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,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.pll;
import io.github.dsheirer.sample.complex.Complex;
/**
* 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
{
public static final double TWO_PI = 2.0 * Math.PI;
private Complex mCurrentVector = new Complex(0, 0);
private double mLoopPhase = 0.0;
private double mLoopFrequency = 0.0;
private double mMaximumLoopFrequency;
private double mDamping = Math.sqrt(2.0) / 2.0;
private double mAlphaGain;
private double mBetaGain;
private Tracking mTracking = Tracking.NORMAL;
/**
* 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;
while(mLoopFrequency > mMaximumLoopFrequency)
{
mLoopFrequency -= 2.0 * mMaximumLoopFrequency;
}
while(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();
}
/**
* Increments the phase of the loop for each sample received at the sample rate.
*/
public void increment()
{
mLoopPhase += mLoopFrequency;
/* Normalize phase between +/- 2 * PI */
if(mLoopPhase > TWO_PI)
{
mLoopPhase -= TWO_PI;
}
if(mLoopPhase < -TWO_PI)
{
mLoopPhase += TWO_PI;
}
}
/**
* 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;
}
/**
* 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);
/* Normalize phase between +/- 2 * PI */
if(mLoopPhase > TWO_PI)
{
mLoopPhase -= TWO_PI;
}
if(mLoopPhase < -TWO_PI)
{
mLoopPhase += TWO_PI;
}
/* Limit frequency to +/- maximum loop frequency */
if(mLoopFrequency > mMaximumLoopFrequency)
{
mLoopFrequency = mMaximumLoopFrequency;
}
if(mLoopFrequency < -mMaximumLoopFrequency)
{
mLoopFrequency = -mMaximumLoopFrequency;
}
}
@Override
public void reset()
{
mLoopPhase = 0.0;
mLoopFrequency = 0.0;
}
}

View File

@@ -0,0 +1,59 @@
/*******************************************************************************
* 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();
/**
* Reset tracking to 0
*/
void reset();
}

View File

@@ -0,0 +1,42 @@
/*******************************************************************************
* 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;
/**
* Phase Locked Loop (PLL) tracking bandwidth - controls how fast/slow the PLL tracks the carrier frequency
*/
public enum Tracking
{
FASTEST(50.0),
FAST(100.0),
NORMAL(200.0),
SLOW(400.0);
private double mLoopBandwidth;
Tracking(double loopBandwidth)
{
mLoopBandwidth = loopBandwidth;
}
/**
* Loop bandwidth setting
*/
public double getLoopBandwidth()
{
return mLoopBandwidth;
}
}

View File

@@ -2,15 +2,19 @@ package io.github.dsheirer.instrument.gui;
import io.github.dsheirer.alias.AliasModel; import io.github.dsheirer.alias.AliasModel;
import io.github.dsheirer.audio.broadcast.BroadcastModel; import io.github.dsheirer.audio.broadcast.BroadcastModel;
import io.github.dsheirer.controller.channel.Channel;
import io.github.dsheirer.controller.channel.ChannelModel; import io.github.dsheirer.controller.channel.ChannelModel;
import io.github.dsheirer.controller.channel.map.ChannelMapModel; import io.github.dsheirer.controller.channel.map.ChannelMapModel;
import io.github.dsheirer.module.decode.DecodeConfigurationEditor; import io.github.dsheirer.module.decode.DecodeConfigurationEditor;
import io.github.dsheirer.module.decode.config.DecodeConfiguration;
import io.github.dsheirer.playlist.PlaylistManager; import io.github.dsheirer.playlist.PlaylistManager;
import io.github.dsheirer.source.IControllableFileSource; import io.github.dsheirer.source.IControllableFileSource;
import net.miginfocom.swing.MigLayout; import net.miginfocom.swing.MigLayout;
import javax.swing.*; import javax.swing.JButton;
import java.awt.*; import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;
import java.awt.Dimension;
import java.awt.event.ActionEvent; import java.awt.event.ActionEvent;
import java.awt.event.ActionListener; import java.awt.event.ActionListener;
@@ -18,14 +22,14 @@ public class DecoderSelectionFrame extends JInternalFrame
{ {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
private Channel mChannel = new Channel();
private DecodeConfigurationEditor mDecodeEditor = new DecodeConfigurationEditor(null); private DecodeConfigurationEditor mDecodeEditor = new DecodeConfigurationEditor(null);
private PlaylistManager mPlaylistManager; private PlaylistManager mPlaylistManager;
private IControllableFileSource mSource; private IControllableFileSource mSource;
private JDesktopPane mDesktop; private JDesktopPane mDesktop;
public DecoderSelectionFrame(JDesktopPane desktop, public DecoderSelectionFrame(JDesktopPane desktop, IControllableFileSource source)
IControllableFileSource source)
{ {
AliasModel aliasModel = new AliasModel(); AliasModel aliasModel = new AliasModel();
BroadcastModel broadcastModel = new BroadcastModel(null); BroadcastModel broadcastModel = new BroadcastModel(null);
@@ -37,6 +41,7 @@ public class DecoderSelectionFrame extends JInternalFrame
mDesktop = desktop; mDesktop = desktop;
mSource = source; mSource = source;
mDecodeEditor.setItem(mChannel);
initGUI(); initGUI();
} }
@@ -72,17 +77,23 @@ public class DecoderSelectionFrame extends JInternalFrame
@Override @Override
public void actionPerformed(ActionEvent arg0) public void actionPerformed(ActionEvent arg0)
{ {
// DecodeConfiguration config = mDecodeEditor.getDecodeConfig(); mDecodeEditor.save();
//
// if( config != null ) Channel channel = mDecodeEditor.getItem();
// {
// DecoderViewFrame decoderFrame = new DecoderViewFrame( if(channel != null)
// mPlaylistManager, null, mSource ); {
// DecodeConfiguration config = channel.getDecodeConfiguration();
// decoderFrame.setVisible( true );
// if( config != null )
// mDesktop.add( decoderFrame ); {
// } DecoderViewFrame decoderFrame = new DecoderViewFrame(mPlaylistManager, channel, mSource );
decoderFrame.setVisible( true );
mDesktop.add( decoderFrame );
}
}
} }
}); });
} }

View File

@@ -0,0 +1,183 @@
/*******************************************************************************
* 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;
import io.github.dsheirer.instrument.gui.viewer.decoder.DecoderPaneFactory;
import io.github.dsheirer.module.decode.DecoderType;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Scene;
import javafx.scene.control.Menu;
import javafx.scene.control.MenuBar;
import javafx.scene.control.MenuItem;
import javafx.scene.control.SeparatorMenuItem;
import javafx.scene.layout.BorderPane;
import javafx.stage.FileChooser;
import javafx.stage.Stage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
/**
* Application for viewing and working with demodulators and recording files.
*/
public class DemodulatorViewerFX extends Application
{
private final static Logger mLog = LoggerFactory.getLogger(DemodulatorViewerFX.class);
private Stage mStage;
private MenuBar mMenuBar;
private RecentFilesMenu mRecentFilesMenu;
private ViewerDesktop mViewerDesktop;
@Override
public void start(Stage primaryStage) throws Exception
{
mStage = primaryStage;
setTitle(null);
BorderPane borderPane = new BorderPane();
borderPane.setTop(getMenuBar());
borderPane.setCenter(getViewerDesktop());
Scene scene = new Scene(borderPane, 1500, 900);
mStage.setScene(scene);
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()
{
if(mViewerDesktop == null)
{
mViewerDesktop = new ViewerDesktop();
}
return mViewerDesktop;
}
private MenuBar getMenuBar()
{
if(mMenuBar == null)
{
mMenuBar = new MenuBar();
Menu fileMenu = new Menu("File");
MenuItem openMenuItem = new MenuItem("Open ...");
openMenuItem.setOnAction(new EventHandler<ActionEvent>()
{
@Override
public void handle(ActionEvent event)
{
FileChooser fileChooser = new FileChooser();
fileChooser.setTitle("Open an I/Q recording file");
File file = fileChooser.showOpenDialog(mStage);
getViewerDesktop().load(file);
getRecentFilesMenu().add(file);
}
});
MenuItem closeMenuItem = new MenuItem("Close");
closeMenuItem.setOnAction(new EventHandler<ActionEvent>()
{
@Override
public void handle(ActionEvent event)
{
getViewerDesktop().close();
}
});
MenuItem exitMenuItem = new MenuItem("Exit");
exitMenuItem.setOnAction(new EventHandler<ActionEvent>()
{
@Override
public void handle(ActionEvent event)
{
Platform.exit();
}
});
fileMenu.getItems().addAll(openMenuItem, getRecentFilesMenu(), closeMenuItem, new SeparatorMenuItem(),
exitMenuItem);
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;
}
private RecentFilesMenu getRecentFilesMenu()
{
if(mRecentFilesMenu == null)
{
mRecentFilesMenu = new RecentFilesMenu("Recent","demodulator.viewer", 5);
mRecentFilesMenu.setFileSelectionListener(new RecentFilesMenu.IFileSelectionListener()
{
@Override
public void fileSelected(File file)
{
getViewerDesktop().load(file);
}
});
}
return mRecentFilesMenu;
}
public static void main(String[] args)
{
launch(args);
}
}

View File

@@ -0,0 +1,311 @@
/*******************************************************************************
* 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;
import io.github.dsheirer.instrument.gui.viewer.decoder.DecoderPane;
import io.github.dsheirer.sample.Broadcaster;
import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.complex.ComplexBuffer;
import io.github.dsheirer.source.IControllableFileSource;
import io.github.dsheirer.source.IFrameLocationListener;
import io.github.dsheirer.source.wave.ComplexWaveSource;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Pos;
import javafx.scene.control.Alert;
import javafx.scene.control.Button;
import javafx.scene.control.ButtonType;
import javafx.scene.control.Label;
import javafx.scene.control.TextField;
import javafx.scene.layout.HBox;
import org.kordamp.ikonli.fontawesome.FontAwesome;
import org.kordamp.ikonli.javafx.FontIcon;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.sound.sampled.UnsupportedAudioFileException;
import java.io.File;
import java.io.IOException;
public class PlaybackController extends HBox implements IFrameLocationListener, Listener<ComplexBuffer>
{
private final static Logger mLog = LoggerFactory.getLogger(PlaybackController.class);
private Button mRewindButton;
private TextField mPlaybackPositionText;
private Button mPlay1Button;
private Button mPlay10Button;
private Button mPlay100Button;
private Button mPlay1000Button;
private HBox mControlsBox;
private Label mFileLabel;
private EventHandler<ActionEvent> mPlayEventHandler;
private DecoderPane mSampleRateListener;
private IControllableFileSource mControllableFileSource;
private Broadcaster<ComplexBuffer> mComplexBufferBroadcaster = new Broadcaster<>();
public PlaybackController()
{
super(10);
getChildren().addAll(getControlsBox(), getFileLabel());
setControlsEnabled(false);
}
public void setSampleRateListener(DecoderPane decoderPane)
{
mSampleRateListener = decoderPane;
if(mSampleRateListener != null && mControllableFileSource != null)
{
mSampleRateListener.setSampleRate(mControllableFileSource.getSampleRate());
}
}
public void load(File file)
{
if(file != null && file.isFile())
{
try
{
mControllableFileSource = new ComplexWaveSource(file);
mControllableFileSource.setListener(this);
((ComplexWaveSource)mControllableFileSource).setListener((Listener<ComplexBuffer>)this);
mControllableFileSource.open();
if(mSampleRateListener != null)
{
mSampleRateListener.setSampleRate(mControllableFileSource.getSampleRate());
}
}
catch(UnsupportedAudioFileException e)
{
mLog.error("Unsupported Audio File Type [" + (file != null ? file.getAbsolutePath() : "null") + "]");
Alert alert = new Alert(Alert.AlertType.ERROR, "The file type is unsupported.", ButtonType.OK);
alert.show();
return;
}
catch(IOException ioe)
{
mLog.error("Error opening file [" + (file != null ? file.getAbsolutePath() : "null") + "]", ioe);
Alert alert = new Alert(Alert.AlertType.ERROR, "There was an error opening the file",
ButtonType.OK);
alert.show();
return;
}
getFileLabel().setText(file.getName());
setControlsEnabled(true);
}
}
public void close()
{
if(mControllableFileSource != null)
{
try
{
mControllableFileSource.close();
}
catch(IOException ioe)
{
mLog.error("Error closing file", ioe);
}
}
setControlsEnabled(false);
}
/**
* Adds listener to receive complex buffers from this playback
*/
public void addListener(Listener<ComplexBuffer> listener)
{
mComplexBufferBroadcaster.addListener(listener);
}
/**
* Removes the listener from receiving complex buffers from this playback
*/
public void removeListener(Listener<ComplexBuffer> listener)
{
mComplexBufferBroadcaster.removeListener(listener);
}
/**
* Sets all of the playback controls to the specified enabled state.
*/
private void setControlsEnabled(boolean enabled)
{
getRewindButton().setDisable(!enabled);
getPlaybackPositionText().setDisable(!enabled);
getPlay1Button().setDisable(!enabled);
getPlay10Button().setDisable(!enabled);
getPlay100Button().setDisable(!enabled);
getPlay1000Button().setDisable(!enabled);
}
private HBox getControlsBox()
{
if(mControlsBox == null)
{
mControlsBox = new HBox();
mControlsBox.getChildren().addAll(getRewindButton(), getPlaybackPositionText(), getPlay1Button(),
getPlay10Button(), getPlay100Button(), getPlay1000Button());
}
return mControlsBox;
}
private Button getRewindButton()
{
if(mRewindButton == null)
{
mRewindButton = new Button();
mRewindButton.setGraphic(new FontIcon(FontAwesome.FAST_BACKWARD));
}
return mRewindButton;
}
private Button getPlay1Button()
{
if(mPlay1Button == null)
{
mPlay1Button = new Button("1");
mPlay1Button.setUserData(1);
mPlay1Button.setOnAction(getPlaybackEventHandler());
mPlay1Button.setGraphic(new FontIcon(FontAwesome.PLAY));
}
return mPlay1Button;
}
private Button getPlay10Button()
{
if(mPlay10Button == null)
{
mPlay10Button = new Button("10");
mPlay10Button.setUserData(10);
mPlay10Button.setOnAction(getPlaybackEventHandler());
mPlay10Button.setGraphic(new FontIcon(FontAwesome.FAST_FORWARD));
}
return mPlay10Button;
}
private Button getPlay100Button()
{
if(mPlay100Button == null)
{
mPlay100Button = new Button("100");
mPlay100Button.setUserData(100);
mPlay100Button.setOnAction(getPlaybackEventHandler());
mPlay100Button.setGraphic(new FontIcon(FontAwesome.FAST_FORWARD));
}
return mPlay100Button;
}
private Button getPlay1000Button()
{
if(mPlay1000Button == null)
{
mPlay1000Button = new Button("1000");
mPlay1000Button.setUserData(1000);
mPlay1000Button.setOnAction(getPlaybackEventHandler());
mPlay1000Button.setGraphic(new FontIcon(FontAwesome.FAST_FORWARD));
}
return mPlay1000Button;
}
private EventHandler<ActionEvent> getPlaybackEventHandler()
{
if(mPlayEventHandler == null)
{
mPlayEventHandler = new EventHandler<ActionEvent>()
{
@Override
public void handle(ActionEvent event)
{
int count = (int)((Button)event.getSource()).getUserData();
if(mControllableFileSource != null)
{
try
{
mControllableFileSource.next(count, true);
}
catch(IOException ioe)
{
mLog.error("Error while playing samples");
}
}
}
};
}
return mPlayEventHandler;
}
private TextField getPlaybackPositionText()
{
if(mPlaybackPositionText == null)
{
mPlaybackPositionText = new TextField("0");
mPlaybackPositionText.setAlignment(Pos.CENTER);
mPlaybackPositionText.setPrefWidth(80);
}
return mPlaybackPositionText;
}
private Label getFileLabel()
{
if(mFileLabel == null)
{
mFileLabel = new Label();
}
return mFileLabel;
}
@Override
public void frameLocationUpdated(int location)
{
getPlaybackPositionText().setText(String.valueOf(location));
}
@Override
public void frameLocationReset()
{
mLog.info("Frame location reset ... ignoring?");
}
@Override
public void receive(ComplexBuffer complexBuffer)
{
mComplexBufferBroadcaster.broadcast(complexBuffer);
}
}

View File

@@ -0,0 +1,192 @@
package io.github.dsheirer.instrument.gui.viewer;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.control.Menu;
import javafx.scene.control.MenuItem;
import javafx.scene.control.SeparatorMenuItem;
import java.io.File;
import java.util.prefs.Preferences;
public class RecentFilesMenu extends Menu implements EventHandler<ActionEvent>
{
private Preferences mPreferences = Preferences.userNodeForPackage(RecentFilesMenu.class);
private IFileSelectionListener mFileSelectionListener;
private String mIdentifier;
private int mSize;
/**
* Recently used files menu. Uses java Preferences to store recently accessed files and provides access to those
* files via child menu items to this menu.
*
* @param label to use for this menu.
* @param uniqueIdentifier to use in addition to the class path of this class to uniquely identify recently accessed
* files in a java Preferences data store.
* @param size of the maximum number of recent files to present to the user
*/
public RecentFilesMenu(String label, String uniqueIdentifier, int size)
{
super(label);
mIdentifier = uniqueIdentifier;
mSize = size;
load();
}
/**
* Registers the listener to receive file selection events when the user selects a recently used file.
* @param listener to receive file selection events
*/
public void setFileSelectionListener(IFileSelectionListener listener)
{
mFileSelectionListener = listener;
}
/**
* Adds the file to the recently accessed files list. If this file is already included in the recently files list,
* it will be promoted to the first menu item and all other recently used files will be demoted.
*
* @param file to add to the recently used files list.
*/
public void add(File file)
{
if(file != null)
{
String filePath = file.getAbsolutePath();
int index = mSize - 1;
//Check to see if this file is already in the recent files list
for(int x = mSize - 1; x >= 0; x--)
{
String existingItem = mPreferences.get(getKey(x), null);
if(existingItem != null && existingItem.equals(filePath))
{
index = x;
break;
}
}
//Shift all recent files down to make room for the newly added file at the top of the list
while(index > 0)
{
String newerItem = mPreferences.get(getKey(index - 1), null);
if(newerItem != null)
{
mPreferences.put(getKey(index), newerItem);
}
index--;
}
mPreferences.put(getKey(0), file.getAbsolutePath());
}
load();
}
/**
* Creates a unique key value for each numbered recently used file item in the preferences.
*
* @param index of recent file item.
* @return unique key to use with the preferences instance.
*/
private String getKey(int index)
{
return mIdentifier + ".recent.file." + index;
}
/**
* Clears and (re)loads all child recent file menu items.
*/
private void load()
{
getItems().clear();
for(int x = 0; x < mSize; x++)
{
String path = mPreferences.get(getKey(x), null);
if(path != null)
{
File file = new File(path);
if(file.isFile())
{
MenuItem menuItem = new MenuItem(file.getName());
menuItem.setUserData(file);
menuItem.setOnAction(this);
getItems().add(menuItem);
}
}
}
if(getItems().size() > 0)
{
setDisable(false);
getItems().add(new SeparatorMenuItem());
MenuItem clearMenuItem = new MenuItem("Clear History");
clearMenuItem.setOnAction(new EventHandler<ActionEvent>()
{
@Override
public void handle(ActionEvent event)
{
clearHistory();
}
});
getItems().add(clearMenuItem);
}
else
{
setDisable(true);
}
}
/**
* Clears the recently used files history and removes all items from the preferences instance
*/
private void clearHistory()
{
for(int x = 0; x < mSize; x++)
{
mPreferences.remove(getKey(x));
}
load();
}
/**
* Event handler for all recent file child menu items. Extracts the selected file stored as the user data object
* in each of the menu items and notifies the listener that the recent file has been selected.
*
* @param event from a recent file menu item child of this menu.
*/
@Override
public void handle(ActionEvent event)
{
if(mFileSelectionListener != null)
{
if(event.getSource() instanceof MenuItem)
{
Object fileObject = ((MenuItem)event.getSource()).getUserData();
if(fileObject instanceof File)
{
mFileSelectionListener.fileSelected((File)fileObject);
}
}
}
}
/**
* Listener interface for file selection events.
*/
public interface IFileSelectionListener
{
void fileSelected(File file);
}
}

View File

@@ -0,0 +1,81 @@
/*******************************************************************************
* 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;
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 java.io.File;
public class ViewerDesktop extends BorderPane
{
private PlaybackController mPlaybackController;
private DecoderPane mDecoderPane = DecoderPaneFactory.getDefaultPane();
public ViewerDesktop()
{
setBottom(getPlaybackController());
setCenter(getDecoderPane());
}
public void load(File file)
{
close();
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()
{
getPlaybackController().close();
}
private PlaybackController getPlaybackController()
{
if(mPlaybackController == null)
{
mPlaybackController = new PlaybackController();
}
return mPlaybackController;
}
}

View File

@@ -0,0 +1,121 @@
/*******************************************************************************
* 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.ComplexCircularBuffer;
import io.github.dsheirer.dsp.gain.ComplexGain;
import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.complex.Complex;
import io.github.dsheirer.sample.complex.ComplexBuffer;
import javafx.beans.property.IntegerProperty;
import javafx.beans.property.SimpleIntegerProperty;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
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 ComplexPhaseLineChart extends LineChart implements Listener<ComplexBuffer>
{
private final static Logger mLog = LoggerFactory.getLogger(ComplexPhaseLineChart.class);
private static final Complex ANGLE_OFFSET_45_DEGREES = Complex.fromAngle(Math.PI / 4.0);
private ComplexCircularBuffer mComplexCircularBuffer;
private ComplexGain mComplexGain = new ComplexGain(600.0f);
private ObservableList<Data<Integer,Float>> mPhaseValues = FXCollections.observableArrayList();
private IntegerProperty mLengthProperty = new SimpleIntegerProperty(40);
public ComplexPhaseLineChart(int length)
{
super(new NumberAxis("Time", 1, length - 10, 2),
new NumberAxis("Phase", -Math.PI, Math.PI, Math.PI / 2.0));
Series<Integer,Float> phaseSeries = new Series<>("Phase", mPhaseValues);
ObservableList<Series<Integer,Float>> observableList = FXCollections.observableArrayList(phaseSeries);
setData(observableList);
init(length);
}
private void init(int length)
{
mLengthProperty.addListener(new ChangeListener<Number>()
{
@Override
public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue)
{
mComplexCircularBuffer = new ComplexCircularBuffer(newValue.intValue());
}
});
mComplexCircularBuffer = new ComplexCircularBuffer(length);
length().setValue(length);
for(int x = 10; x <= length; x++)
{
mPhaseValues.add(new Data(x - 10, 0.0f));
}
}
/**
* Length of the x-axis for displaying samples
*/
public IntegerProperty length()
{
return mLengthProperty;
}
@Override
public void receive(ComplexBuffer complexBuffer)
{
float[] samples = complexBuffer.getSamples();
Complex sample;
for(int x = 0; x < samples.length; x += 2)
{
sample = new Complex(samples[x], samples[x + 1]);
Complex copy = sample.copy();
mComplexGain.apply(copy);
mComplexCircularBuffer.put(copy);
}
updateChart();
}
private void updateChart()
{
Complex[] samples = mComplexCircularBuffer.getAll();
for(int x = 10; x < samples.length; x++)
{
Complex previous = samples[x - 10].copy();
Complex sample = samples[x].copy();
if(previous != null && sample != null)
{
// previous.normalize();
// sample.normalize();
previous.add(ANGLE_OFFSET_45_DEGREES);
sample.multiply(previous.conjugate());
// sample.normalize();
mPhaseValues.get(x - 9).setYValue(sample.angle());
}
}
}
}

View File

@@ -0,0 +1,131 @@
/*******************************************************************************
* 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.ComplexCircularBuffer;
import io.github.dsheirer.dsp.gain.ComplexGain;
import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.complex.Complex;
import io.github.dsheirer.sample.complex.ComplexBuffer;
import javafx.beans.property.IntegerProperty;
import javafx.beans.property.SimpleIntegerProperty;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.scene.chart.LineChart;
import javafx.scene.chart.NumberAxis;
import javafx.scene.chart.XYChart;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ComplexSampleLineChart extends LineChart implements Listener<ComplexBuffer>
{
private final static Logger mLog = LoggerFactory.getLogger(ComplexSampleLineChart.class);
private ComplexCircularBuffer mComplexCircularBuffer;
private ComplexCircularBuffer mDemodulationCircularBuffer;
private ComplexGain mComplexGain = new ComplexGain(500.0f);
private ObservableList<XYChart.Data<Integer,Float>> mISamples = FXCollections.observableArrayList();
private ObservableList<XYChart.Data<Integer,Float>> mQSamples = FXCollections.observableArrayList();
private IntegerProperty mLengthProperty = new SimpleIntegerProperty(40);
public ComplexSampleLineChart(int length, int samplesPerSymbol)
{
super(new NumberAxis("Differential-Demodulated Samples", 0, length, 10),
new NumberAxis("Value", -1.0, 1.0, 0.25));
LineChart.Series<Integer,Float> iSampleSeries = new LineChart.Series<>("Inphase", mISamples);
LineChart.Series<Integer,Float> qSampleSeries = new LineChart.Series<>("Quadrature", mQSamples);
ObservableList<XYChart.Series<Integer,Float>> observableList =
FXCollections.observableArrayList(iSampleSeries, qSampleSeries);
setData(observableList);
init(length, samplesPerSymbol);
}
public void setSamplesPerSymbol(int samplesPerSymbol)
{
mDemodulationCircularBuffer = new ComplexCircularBuffer(samplesPerSymbol);
}
private void init(int length, int samplesPerSymbol)
{
mLengthProperty.addListener(new ChangeListener<Number>()
{
@Override
public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue)
{
mComplexCircularBuffer = new ComplexCircularBuffer(newValue.intValue());
}
});
mComplexCircularBuffer = new ComplexCircularBuffer(length);
mDemodulationCircularBuffer = new ComplexCircularBuffer(samplesPerSymbol);
length().setValue(length);
for(int x = 1; x <= length; x++)
{
mISamples.add(new Data(x, 0.0f));
mQSamples.add(new Data(x, 0.0f));
}
}
/**
* Length of the x-axis for displaying samples
*/
public IntegerProperty length()
{
return mLengthProperty;
}
@Override
public void receive(ComplexBuffer complexBuffer)
{
float[] samples = complexBuffer.getSamples();
Complex sample = new Complex(0,0);
for(int x = 0; x < samples.length; x += 2)
{
sample.setValues(samples[x], samples[x + 1]);
// mComplexGain.apply(sample);
sample.normalize();
Complex previous = mDemodulationCircularBuffer.get(sample.copy());
sample.multiply(previous.conjugate());
mComplexCircularBuffer.put(sample.copy());
}
updateChart();
}
private void updateChart()
{
Complex[] samples = mComplexCircularBuffer.getAll();
for(int x = 0; x < samples.length; x++)
{
Complex sample = samples[x];
if(sample != null)
{
sample.normalize();
mISamples.get(x).setYValue(sample.inphase());
mQSamples.get(x).setYValue(sample.quadrature());
}
}
}
}

View File

@@ -0,0 +1,72 @@
/*******************************************************************************
* 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 DoubleLineChart extends LineChart implements Listener<Double>
{
private final static Logger mLog = LoggerFactory.getLogger(DoubleLineChart.class);
private DoubleCircularBuffer mDoubleCircularBuffer;
private ObservableList<Data<Integer,Double>> mPhaseValues = FXCollections.observableArrayList();
public DoubleLineChart(String seriesLabel, double min, double max, double tick, int length)
{
super(new NumberAxis(1, length, 2), new NumberAxis(min, max, tick));
Series<Integer,Double> phaseSeries = new Series<>(seriesLabel, 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,121 @@
/*******************************************************************************
* 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.dsp.psk.SymbolDecisionData;
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.LineChart;
import javafx.scene.chart.NumberAxis;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class EyeDiagramChart extends LineChart implements Listener<SymbolDecisionData>
{
private final static Logger mLog = LoggerFactory.getLogger(EyeDiagramChart.class);
private ObservableList<Series<Double,Double>> mData = FXCollections.observableArrayList();
private int mSeriesCount;
private int mSeriesPointer;
private int mSeriesLength;
public EyeDiagramChart(int seriesCount)
{
super(new NumberAxis("Symbol Timing (5 = center)", 1.0, 10.0, 1.0),
new NumberAxis("Value", -1.25, 1.25, 0.25));
mSeriesCount = seriesCount * 2;
init();
}
private void init()
{
for(int x = 0; x < mSeriesCount; x++)
{
ObservableList<Data<Double,Double>> series = FXCollections.observableArrayList();
mData.add(new Series<>(series));
}
setData(mData);
}
private ObservableList<Data<Double,Double>> getSeries(int series, int length)
{
ObservableList<Data<Double,Double>> seriesData = mData.get(series).getData();
while(seriesData.size() > length)
{
seriesData.remove(0);
}
while(seriesData.size() < length)
{
seriesData.add(new Data<Double,Double>(0.0,0.0));
}
return seriesData;
}
private void checkChartLength(int length)
{
if(mSeriesLength != length)
{
((NumberAxis)getXAxis()).setUpperBound(length);
mSeriesLength = length;
}
}
@Override
public void receive(SymbolDecisionData symbolDecisionData)
{
Complex[] demodulated = symbolDecisionData.getDemodulated();
int length = demodulated.length;
checkChartLength(length);
ObservableList<Data<Double,Double>> iSeries = getSeries(mSeriesPointer++, length + 1);
if(mSeriesPointer >= mSeriesCount)
{
mSeriesPointer = 0;
}
ObservableList<Data<Double,Double>> qSeries = getSeries(mSeriesPointer++, length + 1);
if(mSeriesPointer >= mSeriesCount)
{
mSeriesPointer = 0;
}
for(int x = 0; x < length; x++)
{
demodulated[x].normalize();
Data<Double,Double> iDataPoint = iSeries.get(x);
iDataPoint.setXValue((double)x + 1 - symbolDecisionData.getSamplingPoint());
double iValue = demodulated[x].inphase();
iDataPoint.setYValue(iValue);
Data<Double,Double> qDataPoint = qSeries.get(x);
qDataPoint.setXValue((double)x + 1 - symbolDecisionData.getSamplingPoint());
double qValue = demodulated[x].quadrature();
qDataPoint.setYValue(qValue);
}
}
}

View File

@@ -0,0 +1,119 @@
/*******************************************************************************
* 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.dsp.fm.FMDemodulator;
import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.complex.Complex;
import io.github.dsheirer.sample.complex.ComplexBuffer;
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 FMDemodulatedLineChart extends LineChart implements Listener<ComplexBuffer>
{
private final static Logger mLog = LoggerFactory.getLogger(FMDemodulatedLineChart.class);
private DoubleCircularBuffer mDoubleCircularBuffer;
private int mSamplesPerSymbol;
private int mTwiceSamplesPerSymbol;
private int mSeriesCount;
private ObservableList<Series<Integer,Double>> mData = FXCollections.observableArrayList();
private Complex mPreviousSample = new Complex(0,0);
private int mSeriesPointer;
private int mSamplePointer;
public FMDemodulatedLineChart(int samplesPerSymbol, int seriesCount)
{
super(new NumberAxis("Time", 1, samplesPerSymbol * 2, 2),
new NumberAxis("Demodulated", -1.0, 1.0, 0.25));
mSamplesPerSymbol = samplesPerSymbol;
mTwiceSamplesPerSymbol = mSamplesPerSymbol * 2;
mSeriesCount = seriesCount;
init();
}
private void init()
{
int seriesLength = 2 * mSamplesPerSymbol;
mDoubleCircularBuffer = new DoubleCircularBuffer(seriesLength * mSeriesCount);
for(int x = 0; x < mSeriesCount; x++)
{
ObservableList<Data<Integer,Double>> series = FXCollections.observableArrayList();
for(int y = 0; y < seriesLength; y++)
{
series.add(new Data<Integer,Double>(y + 1, 0.0));
}
mData.add(new Series<>(series));
}
setData(mData);
}
@Override
public void receive(ComplexBuffer complexBuffer)
{
float[] samples = complexBuffer.getSamples();
Complex sample;
for(int x = 0; x < samples.length; x += 2)
{
sample = new Complex(samples[x], samples[x + 1]);
double demodulated = FMDemodulator.demodulate(mPreviousSample, sample);
demodulated *= 2.0;
if(demodulated > 1.0)
{
demodulated = 1.0;
}
else if(demodulated < -1.0)
{
demodulated = -1.0;
}
mDoubleCircularBuffer.put(demodulated);
mPreviousSample = sample;
updateChart(demodulated);
}
}
private void updateChart(double value)
{
Series<Integer,Double> series = mData.get(mSeriesPointer);
Data data = series.getData().get(mSamplePointer++);
data.setYValue(value);
if(mSamplePointer >= mTwiceSamplesPerSymbol)
{
mSamplePointer = 0;
mSeriesPointer++;
if(mSeriesPointer >= mSeriesCount)
{
mSeriesPointer = 0;
}
}
}
}

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", -0.8, 0.8, 0.1));
Series<Integer,Double> phaseSeries = new Series<>("PLL Phase Error", 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.1, 1.1, 0.2),
new NumberAxis("Q", -1.1, 1.1, 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("Constellation", 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,195 @@
/*******************************************************************************
* 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.ComplexSampleLineChart;
import io.github.dsheirer.instrument.gui.viewer.chart.DoubleLineChart;
import io.github.dsheirer.instrument.gui.viewer.chart.EyeDiagramChart;
import io.github.dsheirer.instrument.gui.viewer.chart.PhaseLineChart;
import io.github.dsheirer.instrument.gui.viewer.chart.SymbolChart;
import io.github.dsheirer.message.Message;
import io.github.dsheirer.module.decode.DecoderType;
import io.github.dsheirer.module.decode.p25.P25_C4FMDecoderInstrumented;
import io.github.dsheirer.sample.Broadcaster;
import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.complex.ComplexBuffer;
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 EyeDiagramChart mEyeDiagramChart;
private HBox mDecoderChartBox;
private SymbolChart mSymbolChart;
private PhaseLineChart mPLLPhaseErrorLineChart;
private DoubleLineChart mPLLFrequencyLineChart;
private DoubleLineChart mSamplesPerSymbolLineChart;
private Broadcaster<ComplexBuffer> mFilteredBufferBroadcaster = new Broadcaster<>();
private P25_C4FMDecoderInstrumented mDecoder = new P25_C4FMDecoderInstrumented(null);
public P25Phase1Pane()
{
super(DecoderType.P25_PHASE1);
init();
}
private void init()
{
addListener(getDecoder());
getDecoder().setFilteredBufferListener(mFilteredBufferBroadcaster);
getDecoder().setSymbolListener(getSymbolChart());
getDecoder().setPLLPhaseErrorListener(getPLLPhaseErrorLineChart());
getDecoder().setPLLFrequencyListener(getPLLFrequencyLineChart());
getDecoder().setSymbolDecisionDataListener(getEyeDiagramChart());
getDecoder().setSamplesPerSymbolListener(getSamplesPerSymbolLineChart());
mFilteredBufferBroadcaster.addListener(getSampleLineChart());
HBox.setHgrow(getSampleChartBox(), Priority.ALWAYS);
HBox.setHgrow(getDecoderChartBox(), Priority.ALWAYS);
getChildren().addAll(getSampleChartBox(), getDecoderChartBox());
mDecoder.setMessageListener(new Listener<Message>()
{
@Override
public void receive(Message message)
{
mLog.debug(message.getMessage());
}
});
}
@Override
public void setSampleRate(double sampleRate)
{
mLog.debug("Configuring for sample rate: " + sampleRate);
mDecoder.setSampleRate(sampleRate);
double samplesPerSymbol = sampleRate / 4800.0;
getSampleLineChart().setSamplesPerSymbol((int)samplesPerSymbol);
}
private P25_C4FMDecoderInstrumented getDecoder()
{
return mDecoder;
}
private SymbolChart getSymbolChart()
{
if(mSymbolChart == null)
{
mSymbolChart = new SymbolChart(10);
}
return mSymbolChart;
}
private HBox getDecoderChartBox()
{
if(mDecoderChartBox == null)
{
mDecoderChartBox = new HBox();
mDecoderChartBox.setMaxHeight(Double.MAX_VALUE);
getSymbolChart().setMaxWidth(Double.MAX_VALUE);
getPLLPhaseErrorLineChart().setMaxWidth(Double.MAX_VALUE);
getPLLFrequencyLineChart().setMaxWidth(Double.MAX_VALUE);
HBox.setHgrow(getSymbolChart(), Priority.ALWAYS);
HBox.setHgrow(getPLLPhaseErrorLineChart(), Priority.ALWAYS);
HBox.setHgrow(getPLLFrequencyLineChart(), Priority.ALWAYS);
mDecoderChartBox.getChildren().addAll(getSymbolChart(), getPLLPhaseErrorLineChart(),
getPLLFrequencyLineChart());
}
return mDecoderChartBox;
}
private HBox getSampleChartBox()
{
if(mSampleChartBox == null)
{
mSampleChartBox = new HBox();
mSampleChartBox.setMaxHeight(Double.MAX_VALUE);
getSampleLineChart().setMaxWidth(Double.MAX_VALUE);
getEyeDiagramChart().setMaxWidth(Double.MAX_VALUE);
getSamplesPerSymbolLineChart().setMaxWidth(Double.MAX_VALUE);
HBox.setHgrow(getSampleLineChart(), Priority.ALWAYS);
HBox.setHgrow(getEyeDiagramChart(), Priority.ALWAYS);
HBox.setHgrow(getSamplesPerSymbolLineChart(), Priority.ALWAYS);
mSampleChartBox.getChildren().addAll(getSampleLineChart(), getEyeDiagramChart(),
getSamplesPerSymbolLineChart());
}
return mSampleChartBox;
}
private ComplexSampleLineChart getSampleLineChart()
{
if(mSampleLineChart == null)
{
mSampleLineChart = new ComplexSampleLineChart(100, 10);
}
return mSampleLineChart;
}
private EyeDiagramChart getEyeDiagramChart()
{
if(mEyeDiagramChart == null)
{
mEyeDiagramChart = new EyeDiagramChart(10);
}
return mEyeDiagramChart;
}
private PhaseLineChart getPLLPhaseErrorLineChart()
{
if(mPLLPhaseErrorLineChart == null)
{
mPLLPhaseErrorLineChart = new PhaseLineChart(40);
}
return mPLLPhaseErrorLineChart;
}
private DoubleLineChart getPLLFrequencyLineChart()
{
if(mPLLFrequencyLineChart == null)
{
mPLLFrequencyLineChart = new DoubleLineChart( "PLL Frequency", -500, 500, 50, 40);
}
return mPLLFrequencyLineChart;
}
private DoubleLineChart getSamplesPerSymbolLineChart()
{
if(mSamplesPerSymbolLineChart == null)
{
mSamplesPerSymbolLineChart = new DoubleLineChart( "Sample Point", 9.5, 11.5, 0.1, 40);
}
return mSamplesPerSymbolLineChart;
}
}

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

@@ -246,9 +246,7 @@ public class DecoderFactory
switch(modulation) switch(modulation)
{ {
case C4FM: case C4FM:
modules.add(new FMDemodulatorModule(P25_C4FM_IQ_FILTER)); modules.add(new P25_C4FMDecoder(aliasList));
modules.add(new DemodulatedAudioFilterModule(P25_C4FM_DEMOD_FILTER, 1.0f));
modules.add(new P25_C4FMDecoder(aliasList, decodeConfig.getAFCMaximumCorrection()));
modules.add(new P25DecoderState(aliasList, channelType, P25Decoder.Modulation.C4FM, modules.add(new P25DecoderState(aliasList, channelType, P25Decoder.Modulation.C4FM,
p25Config.getIgnoreDataCalls())); p25Config.getIgnoreDataCalls()));
break; break;

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

@@ -1,97 +1,180 @@
/******************************************************************************* /*******************************************************************************
* sdrtrunk * sdr-trunk
* Copyright (C) 2014-2017 Dennis Sheirer * Copyright (C) 2014-2018 Dennis Sheirer
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public
* it under the terms of the GNU General Public License as published by * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
* the Free Software Foundation, either version 3 of the License, or * later version.
* (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
* but WITHOUT ANY WARRANTY; without even the implied warranty of * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
* 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 * You should have received a copy of the GNU General Public License along with this program.
* along with this program. If not, see <http://www.gnu.org/licenses/> * 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.tap.Tap; import io.github.dsheirer.dsp.filter.FilterFactory;
import io.github.dsheirer.instrument.tap.TapGroup; import io.github.dsheirer.dsp.filter.design.FilterDesignException;
import io.github.dsheirer.instrument.tap.stream.DibitTap; import io.github.dsheirer.dsp.filter.fir.FIRFilterSpecification;
import io.github.dsheirer.instrument.tap.stream.FloatTap; import io.github.dsheirer.dsp.filter.fir.complex.ComplexFIRFilter;
import io.github.dsheirer.dsp.psk.DQPSKDemodulator;
import io.github.dsheirer.dsp.psk.InterpolatingSampleBuffer;
import io.github.dsheirer.dsp.psk.InterpolatingSampleBufferInstrumented;
import io.github.dsheirer.dsp.psk.pll.CostasLoop;
import io.github.dsheirer.sample.Listener; import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.real.IFilteredRealBufferListener; import io.github.dsheirer.sample.complex.ComplexBuffer;
import io.github.dsheirer.sample.real.RealBuffer; import io.github.dsheirer.sample.complex.IComplexBufferListener;
import io.github.dsheirer.source.tuner.frequency.FrequencyChangeEvent; 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.HashMap;
import java.util.List; import java.util.Map;
import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledExecutorService;
public class P25_C4FMDecoder extends P25Decoder implements IFilteredRealBufferListener public class P25_C4FMDecoder extends P25Decoder implements IComplexBufferListener, Listener<ComplexBuffer>
{ {
private final static Logger mLog = LoggerFactory.getLogger( P25_C4FMDecoder.class ); private final static Logger mLog = LoggerFactory.getLogger(P25_C4FMDecoder.class);
protected static final double SYMBOL_RATE = 4800;
protected InterpolatingSampleBuffer mInterpolatingSampleBuffer;
protected DQPSKDemodulator mQPSKDemodulator;
protected CostasLoop mCostasLoop;
protected P25MessageFramer mMessageFramer;
protected double mSampleRate;
private Map<Double,float[]> mBasebandFilters = new HashMap<>();
private ComplexFIRFilter mBasebandFilter;
/* Instrumentation Taps */ public P25_C4FMDecoder(AliasList aliasList)
private static final String INSTRUMENT_C4FM_SYMBOL_FILTER_OUTPUT = "Tap Point: Symbol Filter Output";
private static final String INSTRUMENT_C4FM_SLICER_OUTPUT = "Tap Point: C4FM Slicer Output";
private List<TapGroup> mAvailableTaps;
private C4FMSymbolFilter mSymbolFilter;
private C4FMSlicer mC4FMSlicer;
private P25MessageFramer mMessageFramer;
/**
* P25 Phase 1 C4FM Decoder processes real buffers of un-filtered,
* demodulated audio and produces decoded P25 Phase 1 Messages.
*
* Provides Frequency Control to steer external tuner source and incorporates
* internal gain control.
*
* Note: use the P25AudioModule to convert the decoded messages into audio.
*
* @param aliasList - optional (can be null) list of alias values for network
* infrastructure and subscriber identities that will be included in each
* decoded message
*/
public P25_C4FMDecoder(AliasList aliasList, int frequencyCorrectionMaximum )
{ {
super( aliasList ); super(aliasList);
setSampleRate(48000.0);
}
/* Shape gain and frequency offsets to optimize sample stream */ public void setSampleRate(double sampleRate)
mSymbolFilter = new C4FMSymbolFilter( frequencyCorrectionMaximum ); {
if(sampleRate <= SYMBOL_RATE * 2)
{
throw new IllegalArgumentException("Sample rate must be at least twice the symbol rate [4800]");
}
/* Convert samples to symbols */ mSampleRate = sampleRate;
mC4FMSlicer = new C4FMSlicer(); mBasebandFilter = new ComplexFIRFilter(getBasebandFilter(), 1.0f);
mSymbolFilter.setListener( mC4FMSlicer );
/* Sync pattern detection and message construction */ mCostasLoop = new CostasLoop(mSampleRate, SYMBOL_RATE);
mMessageFramer = new P25MessageFramer( aliasList );
mC4FMSlicer.addListener( mMessageFramer );
/* Process and broadcast messages */ mInterpolatingSampleBuffer = new InterpolatingSampleBufferInstrumented((float)(sampleRate / SYMBOL_RATE));
mMessageFramer.setListener( getMessageProcessor() ); mQPSKDemodulator = new DQPSKDemodulator(mCostasLoop, mInterpolatingSampleBuffer);
//Message framer can trigger a symbol-inversion correction to the PLL when detected
mMessageFramer = new P25MessageFramer(getAliasList(), mCostasLoop);
mMessageFramer.setListener(getMessageProcessor());
mQPSKDemodulator.setDibitListener(mMessageFramer);
} }
@Override @Override
public void receive(ComplexBuffer complexBuffer)
{
ComplexBuffer filtered = filter(complexBuffer);
mQPSKDemodulator.receive(filtered);
}
protected ComplexBuffer filter(ComplexBuffer complexBuffer)
{
return mBasebandFilter.filter(complexBuffer);
}
private double getSampleRate()
{
return mSampleRate;
}
private float[] getBasebandFilter()
{
float[] filter = mBasebandFilters.get(getSampleRate());
if(filter == null)
{
FIRFilterSpecification specification = FIRFilterSpecification.lowPassBuilder()
.sampleRate((int)getSampleRate())
.passBandCutoff(5100)
.passBandAmplitude(1.0)
.passBandRipple(0.01)
.stopBandAmplitude(0.0)
.stopBandStart(6500)
.stopBandRipple(0.01)
.build();
try
{
filter = FilterFactory.getTaps(specification);
}
catch(FilterDesignException fde)
{
mLog.error("Couldn't design low pass baseband filter for sample rate: " + getSampleRate());
}
if(filter != null)
{
mBasebandFilters.put(getSampleRate(), filter);
}
else
{
throw new IllegalStateException("Couldn't design a C4FM symbol filter for sample rate: " + mSampleRate);
}
}
return filter;
}
public void dispose() public void dispose()
{ {
super.dispose(); super.dispose();
mSymbolFilter.dispose(); mBasebandFilter.dispose();
mSymbolFilter = null; mBasebandFilter = null;
mMessageFramer.dispose(); mMessageFramer.dispose();
mMessageFramer = null; mMessageFramer = null;
}
mC4FMSlicer.dispose(); @Override
mC4FMSlicer = null; 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)
{
switch(frequencyChangeEvent.getEvent())
{
case NOTIFICATION_FREQUENCY_CHANGE:
case NOTIFICATION_FREQUENCY_CORRECTION_CHANGE:
case NOTIFICATION_CHANNEL_FREQUENCY_CORRECTION_CHANGE:
case NOTIFICATION_SAMPLE_RATE_CHANGE:
mCostasLoop.reset();
break;
}
}
};
}
@Override
public Listener<ComplexBuffer> getComplexBufferListener()
{
return P25_C4FMDecoder.this;
} }
public Modulation getModulation() public Modulation getModulation()
@@ -99,146 +182,19 @@ public class P25_C4FMDecoder extends P25Decoder implements IFilteredRealBufferLi
return Modulation.C4FM; return Modulation.C4FM;
} }
@Override
public Listener<RealBuffer> getFilteredRealBufferListener()
{
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()
{ {
// TODO Auto-generated method stub mCostasLoop.reset();
} }
@Override @Override
public void start( ScheduledExecutorService executor ) public void start(ScheduledExecutorService executor)
{ {
// TODO Auto-generated method stub
} }
@Override @Override
public void stop() public void stop()
{ {
// TODO Auto-generated method stub
}
@Override
public void setFrequencyChangeListener( Listener<FrequencyChangeEvent> listener )
{
if( mSymbolFilter != null )
{
mSymbolFilter.setFrequencyChangeListener( listener );
}
}
@Override
public void removeFrequencyChangeListener()
{
if( mSymbolFilter != null )
{
mSymbolFilter.setFrequencyChangeListener( null );
}
}
@Override
public Listener<FrequencyChangeEvent> getFrequencyChangeListener()
{
if( mSymbolFilter != null )
{
return mSymbolFilter.getFrequencyChangeListener();
}
return null;
} }
} }

View File

@@ -0,0 +1,109 @@
/*******************************************************************************
* 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.psk.DQPSKDemodulatorInstrumented;
import io.github.dsheirer.dsp.psk.InterpolatingSampleBufferInstrumented;
import io.github.dsheirer.dsp.psk.SymbolDecisionData;
import io.github.dsheirer.sample.Listener;
import io.github.dsheirer.sample.complex.Complex;
import io.github.dsheirer.sample.complex.ComplexBuffer;
public class P25_C4FMDecoderInstrumented extends P25_C4FMDecoder
{
private Listener<Double> mPLLPhaseErrorListener;
private Listener<Double> mPLLFrequencyListener;
private Listener<Double> mSamplesPerSymbolListener;
private Listener<Complex> mSymbolListener;
private Listener<ComplexBuffer> mFilteredSymbolListener;
private Listener<SymbolDecisionData> mSymbolDecisionDataListener;
public P25_C4FMDecoderInstrumented(AliasList aliasList)
{
super(aliasList);
}
/**
* Overrides the filter method so that we can capture the filtered samples for instrumentation
*/
protected ComplexBuffer filter(ComplexBuffer complexBuffer)
{
ComplexBuffer filtered = super.filter(complexBuffer);
if(mFilteredSymbolListener != null)
{
mFilteredSymbolListener.receive(filtered);
}
return filtered;
}
/**
* Overrides this method so we can correctly configure for instrumented operations
*/
public void setSampleRate(double sampleRate)
{
super.setSampleRate(sampleRate);
InterpolatingSampleBufferInstrumented instrumentedBuffer = new InterpolatingSampleBufferInstrumented((float)(sampleRate / SYMBOL_RATE));
mInterpolatingSampleBuffer = instrumentedBuffer;
DQPSKDemodulatorInstrumented instrumented = new DQPSKDemodulatorInstrumented(mCostasLoop, instrumentedBuffer, mSampleRate);
mQPSKDemodulator = instrumented;
instrumented.setSymbolListener(mSymbolListener);
instrumented.setPLLErrorListener(mPLLPhaseErrorListener);
instrumented.setPLLFrequencyListener(mPLLFrequencyListener);
instrumented.setSymbolDecisionDataListener(mSymbolDecisionDataListener);
instrumented.setSamplesPerSymbolListener(mSamplesPerSymbolListener);
instrumented.setDibitListener(mMessageFramer);
}
public void setSymbolListener(Listener<Complex> listener)
{
mSymbolListener = listener;
((DQPSKDemodulatorInstrumented)mQPSKDemodulator).setSymbolListener(listener);
}
public void setPLLPhaseErrorListener(Listener<Double> listener)
{
mPLLPhaseErrorListener = listener;
((DQPSKDemodulatorInstrumented)mQPSKDemodulator).setPLLErrorListener(listener);
}
public void setPLLFrequencyListener(Listener<Double> listener)
{
mPLLFrequencyListener = listener;
((DQPSKDemodulatorInstrumented)mQPSKDemodulator).setPLLFrequencyListener(listener);
}
public void setFilteredBufferListener(Listener<ComplexBuffer> listener)
{
mFilteredSymbolListener = listener;
}
public void setSymbolDecisionDataListener(Listener<SymbolDecisionData> listener)
{
mSymbolDecisionDataListener = listener;
((DQPSKDemodulatorInstrumented)mQPSKDemodulator).setSymbolDecisionDataListener(listener);
}
public void setSamplesPerSymbolListener(Listener<Double> listener)
{
mSamplesPerSymbolListener = listener;
((DQPSKDemodulatorInstrumented)mQPSKDemodulator).setSamplesPerSymbolListener(listener);
}
}

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

@@ -78,7 +78,7 @@ public class SyncBroadcast extends TSBKMessage
if( isMicroslotsLockedToMinuteRollover() ) if( isMicroslotsLockedToMinuteRollover() )
{ {
sb.append( " MICROSLOT-MINUTE ROLLOVER:LOCKED" ); sb.append( " MICROSLOT-MINUTE ROLLOVER:SLOW" );
} }
else else
{ {

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

@@ -21,14 +21,13 @@ public class ConversionUtils
*/ */
public static float[] convertFromSigned16BitSamples( ByteBuffer buffer ) public static float[] convertFromSigned16BitSamples( ByteBuffer buffer )
{ {
ShortBuffer byteBuffer = ShortBuffer byteBuffer = buffer.order( ByteOrder.LITTLE_ENDIAN ).asShortBuffer();
buffer.order( ByteOrder.LITTLE_ENDIAN ).asShortBuffer();
float[] samples = new float[ buffer.limit() / 2 ]; float[] samples = new float[ buffer.limit() / 2 ];
for( int x = 0; x < samples.length; x++ ) for( int x = 0; x < samples.length; x++ )
{ {
samples[ x ] = (float)byteBuffer.get() / 32767.0f; samples[ x ] = (float)byteBuffer.get() / (float)Short.MAX_VALUE;
} }
return samples; return samples;

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,12 @@ 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()
{
return (float)Math.toDegrees(angle());
} }
/** /**
@@ -363,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;
} }
@@ -389,7 +409,7 @@ public class Complex implements Serializable
*/ */
public float polarAngle() public float polarAngle()
{ {
return (float)Math.toDegrees( angle() ); return (float)Math.toDegrees(angle());
} }
/** /**
@@ -397,37 +417,34 @@ 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 Complex ROTATE_FROM_MINUS_45 = Complex.fromAngle(1.0 * Math.PI / 4.0);
Complex ROTATE_FROM_PLUS_135 = Complex.fromAngle(-3.0 * Math.PI / 4.0);
mLog.debug("REF: " + ROTATE_FROM_MINUS_45.toString());
Complex s1 = new Complex( (float)Math.sin( angle ), (float)Math.cos( angle ) ); Complex symbol = new Complex(0.7665009f, -0.6422432f);
mLog.debug("SYM: " + symbol.toString());
Complex tap = new Complex( 1.0f, -0.1f );
Complex convolved = Complex.multiply( s1, tap );
mLog.debug( "s: " + s1.toString() +
" t: " + tap.toString() +
" convolved: " + convolved.toString() );
symbol.multiply(ROTATE_FROM_MINUS_45);
mLog.debug("DER: " + symbol.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);
} }

View File

@@ -469,6 +469,7 @@ public class TunerChannelSource extends ComplexSource implements IFrequencyChang
{ {
//Frequency correction requests are the only change requests supported from downstream components //Frequency correction requests are the only change requests supported from downstream components
case REQUEST_CHANNEL_FREQUENCY_CORRECTION_CHANGE: case REQUEST_CHANNEL_FREQUENCY_CORRECTION_CHANGE:
mLog.debug("Got a freq corr change request: " + event.getValue().intValue());
setFrequencyCorrection(event.getValue().intValue()); setFrequencyCorrection(event.getValue().intValue());
break; break;
} }

View File

@@ -167,14 +167,9 @@ public class ComplexWaveSource extends ComplexSource implements IControllableFil
if(mInputStream != null) if(mInputStream != null)
{ {
mInputStream.close(); mInputStream.close();
}
else
{
throw new IOException("Can't close wave source - was not opened");
}
mInputStream = null; mInputStream = null;
} }
}
/** /**
* Opens the source file for reading * Opens the source file for reading
@@ -239,8 +234,7 @@ public class ComplexWaveSource extends ComplexSource implements IControllableFil
buffer = Arrays.copyOf(buffer, samplesRead); buffer = Arrays.copyOf(buffer, samplesRead);
} }
float[] samples = ConversionUtils float[] samples = ConversionUtils.convertFromSigned16BitSamples(buffer);
.convertFromSigned16BitSamples(buffer);
mListener.receive(new ComplexBuffer(samples)); mListener.receive(new ComplexBuffer(samples));
} }